[libc++][P0053R7] Add <syncstream> header and implement std::basic_syncbuf

[Mordante]

Summary

Add C++20 header <syncstream> and implement std::basic_syncbuf as described in P0053R7

[abrachet]

This is my first contribution to libcxx/ I tried my best to match style etc but bear with me :)

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

571–572

Not sure why make generate-cxx-abilist touched these, does anyone have any ideas? LLVM_USE_SANITIZER perhaps?

[curdeius]

Hi and thanks for the patch!

Please mark the new tests with // UNSUPPORTED: c++03, c++11, c++14, c++17.
Update and run utils/generate_feature_test_macro_components.py to add __cpp_lib_syncstream feature test macro.
Also please update status page for this paper in docs/.

Update should trigger CI.

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.assign/member_swap.pass.cpp

17

You should mark all your tests as UNSUPPORTED: for all previous standards.

[abrachet]

In D92790#2439170, @curdeius wrote:

Hi and thanks for the patch!

Please mark the new tests with // UNSUPPORTED: c++03, c++11, c++14, c++17.
Update and run utils/generate_feature_test_macro_components.py to add __cpp_lib_syncstream feature test macro.

I made this __cpp_lib_syncbuf looks like thats what the macro is supposed to be called, https://en.cppreference.com/w/cpp/feature_test#Library_features

Also please update status page for this paper in docs/.

Update should trigger CI.

Thanks for the suggestions.

[tschuett]

https://github.com/llvm-mirror/libcxx/blob/master/NOTES.TXT#L19-L29

[mclow.lists]

I'm not seeing any coordination between different syncbufs on the same stream here.
My impression was that implementing this required a global registry of streams that had syscstreams associated with them.

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

571–572

If these things have changed sizes, that's an ABI break.

[abrachet]

Add _LIBCPP_VERSION test

[abrachet]

In D92790#2444240, @mclow.lists wrote:

I'm not seeing any coordination between different syncbufs on the same stream here.
My impression was that implementing this required a global registry of streams that had syscstreams associated with them.

syncbuf has an internal __mutex type which maps streambuf_type *'s to mutexes

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

Still not sure why these are here though.

571–572

Looks like it was asan which did this.

[curdeius]

FYI, I've just landed D92656, so now you can use utils/generate_header_tests.py to generate (some) tests for a new header. You might need to modify the script to add condition on _LIBCPP_HAS_NO_THREADS. Anyway, what you did on tests looks good.
Also, notes are now at https://libcxx.llvm.org/docs/Contributing.html.

Just a few comments for the moment, I'll take time to review it a bit later.

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

It all depends on your environment and link flags. Once CI gets triggered you'd be able to get updated ABI lists from artifacts on failed build steps (in Buildkite). You'll probably need to remove these unrelated changes (exception, align_val_t).

571–572

Just to help reviewing, please mark addressed comments as "Done".

[curdeius]

As a general note, the test paths should match the paragraphs in the standard.
So, e.g. libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.assign/member_swap.pass.cpp should be libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.assign/swap.pass.cpp.
@ldionne, please correct me on that if I'm wrong.

Also, you seem to lack a test on the destructor (that it correctly calls emit and doesn't throw).

Anyway, in general, I like your implementation.

libcxx/docs/Cxx2aStatusPaperStatus.csv

196

It would be nice if you added a note on what's implemented and what's not (see Cxx2aStatus.rst).

libcxx/include/syncstream

14

You should also update the synopsis of <iosfwd>. Cf. paragraph 3.2 of the paper.

64–98

I never know, should unimplemented parts be present in the synopsis? @ldionne?

135–137

This ctor should be splitted in two, one of them being explicit and taking 0 or 1 params, cf. synopsis.

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.cons/default.pass.cpp

17

Also here, please add tests for explicit. Cf. below.

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.cons/wrapped.pass.cpp

17

You should also test that you can't construct it implicitly. You may use test_convertible for that.
You might have a look at D91292.

[abrachet]

• Add note to Cxx2aStatus.rst
• update synopsis of <iosfwd>
• Split ctor
• Update emit_mt.pass.cpp to use more threads
• Fix race condition in getting lock in mutex::mutex
• Fix set_emit_on_sync test which didn’t end with .pass.cpp so it wasn’t being tested previously (oops)
• Move dtor tests from emit test to its own test
• Renamed test files as suggested

[abrachet]

Thanks a lot for the comments @curdeius

libcxx/include/syncstream

14

Thanks, good catch

64–98

I have removed them for now

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

How does CI get triggered for libcxx? You mentioned it in a previous comment, but will that be only after pushing the changes?

[curdeius]

libcxx/docs/Cxx2aStatusPaperStatus.csv

6

You should update the status here instead of adding a new line. BTW, maybe drop R7 in the note.

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

Ahhh, I think I know what may happen. How do you upload the patches? You don't use arcanist, do you?
It seems that the problem when uploading patches through the web GUI is that it removes the set repository (rG LLVM Github Monorepo).
@mstorsjo had the same problems, apparently updating the patch twice (and setting the repo in the middle) triggers the CI if I understood correctly.
@ldionne, can we do something to fix that?
@abrachet, can you try using arcanist (arc)? See https://www.llvm.org/docs/Phabricator.html?highlight=arcanist#id3

[mstorsjo]

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

Yes - so far, it seems like if the patch already has the repo set, it still looks like it's set while updating the diff (and removing and readding it in the last step doesn't help), but after submitting, it's gone. So I guess one either has to explicitly remove the repo before updating a patch, or update it twice (so that one can re-set the repo the second time, to make CI pick it up again).

FWIW, I don't think the repo setting is something specific to the libcxx hooks, but sounds to me more like a phabricator issue.

[zoecarver]

Hey @abrachet. Thanks for the patch. Just FYI, I've got D67086 which also implements syncbuf. Maybe we can coordinate on how to merge these patches.

[curdeius]

Requesting changes so that it shows up nicely in the review queue.
@abrachet, could you please sync with Zoe and possibly merge your two patches?

[Mordante]

@abrachet are you still interested in this patch. I just restarted work on D67086. Do you want to work together or do you prefer me to finish this project?

[Mordante]

I had a closer look at this patch. I think the other patch now is more complete. Abandoning it to clean up the review queue.

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version"
 "`P0463R1 <https://wg21.link/P0463R1>`__","LWG","Endian just Endian","Toronto","|Complete|","7.0"
 "`P0674R1 <https://wg21.link/P0674R1>`__","LWG","Extending make_shared to Support Arrays","Toronto","",""
 "","","","","",""
 "`P0020R6 <https://wg21.link/P0020R6>`__","LWG","Floating Point Atomic","Albuquerque","",""
 "`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","",""
 "`P0202R3 <https://wg21.link/P0202R3>`__","LWG","Add constexpr modifiers to functions in <algorithm> and <utility> Headers","Albuquerque","|Complete|","12.0"
 "`P0415R1 <https://wg21.link/P0415R1>`__","LWG","Constexpr for ``std::complex``\ ","Albuquerque","|In Progress|","7.0"
 "`P0439R0 <https://wg21.link/P0439R0>`__","LWG","Make ``std::memory_order``\  a scoped enumeration","Albuquerque","|Complete|",""
 "`P0457R2 <https://wg21.link/P0457R2>`__","LWG","String Prefix and Suffix Checking","Albuquerque","|Complete|","6.0"
 "`P0550R2 <https://wg21.link/P0550R2>`__","LWG","Transformation Trait ``remove_cvref``\ ","Albuquerque","|Complete|","6.0"
 "`P0600R1 <https://wg21.link/P0600R1>`__","LWG","nodiscard in the Library","Albuquerque","|In Progress| [#note-P0600]_","7.0"
 "`P0616R0 <https://wg21.link/P0616R0>`__","LWG","de-pessimize legacy <numeric> algorithms with std::move","Albuquerque","|Complete|","12.0"
 "`P0653R2 <https://wg21.link/P0653R2>`__","LWG","Utility to convert a pointer to a raw pointer","Albuquerque","|Complete|","6.0"

 "`P2002 <https://wg21.link/P2002>`__","CWG","Defaulted comparison specification cleanups","Prague","* *",""
 "`P2045 <https://wg21.link/P2045>`__","LWG","Missing Mandates for the standard library","Prague","* *",""
 "`P2085 <https://wg21.link/P2085>`__","CWG","Consistent defaulted comparisons","Prague","* *",""
 "`P2091 <https://wg21.link/P2091>`__","LWG","Issues with range access CPOs","Prague","* *",""
 "`P2101 <https://wg21.link/P2101>`__","LWG","'Models' subsumes 'satisfies' (Wording for US298 and US300)","Prague","* *",""
 "`P2102 <https://wg21.link/P2102>`__","LWG","Make 'implicit expression variations' more explicit (Wording for US185)","Prague","* *",""
 "`P2106 <https://wg21.link/P2106>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *",""
 "`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
+"`P0053R7 <https://wg21.link/P0053R7>`__","LWG","<syncstream>","Albuquerque","|Partial|","12.0"

libcxx/include/CMakeLists.txt

set(files
   support/solaris/floatingpoint.h
   support/solaris/wchar.h
   support/solaris/xlocale.h
   support/win32/limits_msvc_win32.h
   support/win32/locale_win32.h
   support/xlocale/__nop_locale_mgmt.h
   support/xlocale/__posix_l_fallback.h
   support/xlocale/__strtonum_fallback.h
+  syncstream
   system_error
   tgmath.h
   thread
   tuple
   type_traits
   typeindex
   typeinfo
   unordered_map

libcxx/include/syncstream

+// -*- C++ -*-
+//===-------------------------- syncstream -------------------------------===//
+//
+// 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
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SYNCSTREAM
+#define _LIBCPP_SYNCSTREAM
+
+/*
+    syncstream synopsis
+
+namespace std {
+
+  template <class charT,
+            class traits,
+            class Allocator>
+  class basic_syncbuf
+    : public basic_streambuf<charT, traits> {
+
+  public:
+    using char_type      = charT;
+    using int_type       = typename traits::int_type;
+    using pos_type       = typename traits::pos_type;
+    using off_type       = typename traits::off_type;
+    using traits_type    = traits;
+    using allocator_type = Allocator;
+  
+    using streambuf_type = basic_streambuf<charT, traits>;
+
+    explicit
+    basic_syncbuf(streambuf_type* obuf = nullptr)
+      : basic_syncbuf(obuf, Allocator()) { }
+    basic_syncbuf(streambuf_type*, const Allocator&);
+    basic_syncbuf(basic_syncbuf&&);
+    ~basic_syncbuf();
+
+    basic_syncbuf& operator=(basic_syncbuf&&);
+    void swap(basic_syncbuf&);
+
+    bool emit();
+    streambuf_type* get_wrapped()    const noexcept;
+    allocator_type  get_allocator()  const noexcept;
+    void            set_emit_on_sync(bool) noexcept;
+
+  protected:
+    int sync() override;
+
+  private:
+    streambuf_type* wrapped;        // exposition only
+    bool            emit_on_sync{}; // exposition only
+};
+
+  template <class charT, class traits, class Allocator>
+  void swap(basic_syncbuf<charT, traits, Allocator>&,
+            basic_syncbuf<charT, traits, Allocator>&);
+
+  using syncbuf = basic_syncbuf<char>;
+  using wsyncbuf = basic_syncbuf<wchar_t>;
+
+  template <class charT,
+            class traits,
+            class Allocator>
+  class basic_osyncstream
+    : public basic_ostream<charT, traits>
+  {
+  public:
+    using char_type      = charT;
+    using int_type       = typename traits::int_type;
+    using pos_type       = typename traits::pos_type;
+    using off_type       = typename traits::off_type;
+    using traits_type    = traits;
+    using allocator_type = Allocator;
+    using streambuf_type = basic_streambuf<charT, traits>;
+    using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
+
+    basic_osyncstream(streambuf_type*, const Allocator&);
+    explicit basic_osyncstream(streambuf_type* obuf)
+      : basic_osyncstream(obuf, Allocator()) { }
+    basic_osyncstream(basic_ostream<charT, traits>& os, const Allocator& allocator)
+      : basic_osyncstream(os.rdbuf(), allocator) { }
+    explicit basic_osyncstream(basic_ostream<charT, traits>& os)
+      : basic_osyncstream(os, Allocator()) { }
+    basic_osyncstream(basic_osyncstream&&) noexcept;
+    ~basic_osyncstream();
+    basic_osyncstream& operator=(basic_osyncstream&&) noexcept;
+    void            emit();
+    streambuf_type* get_wrapped() const noexcept;
+    syncbuf_type*   rdbuf() const noexcept { return &sb ; }
+  private:
+    syncbuf_type sb; // exposition only
+  };
+
+  using osyncstream = basic_osyncstream<char>;
+  using wosyncstream = basic_osyncstream<wchar_t>;
+
+} // namespace std
+
+*/
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#include <__config>
+#include <sstream>
+#include <map>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template <class charT,
+          class traits = char_traits<charT>,
+          class Allocator = allocator<charT>>
+class _LIBCPP_TYPE_VIS basic_syncbuf
+    : public basic_streambuf<charT, traits>
+{
+public:
+    using char_type      = charT;
+    using int_type       = typename traits::int_type;
+    using pos_type       = typename traits::pos_type;
+    using off_type       = typename traits::off_type;
+    using traits_type    = traits;
+    using allocator_type = Allocator;
+  
+    using streambuf_type = basic_streambuf<charT, traits>;
+
+    using string_type = basic_string<charT, traits, Allocator>;
+    using stringbuf_type = basic_stringbuf<charT, traits, Allocator>;
+
+    basic_syncbuf(streambuf_type* __obuf = nullptr,
+                  const allocator_type& __a = allocator_type{})
+        : __mtx(__obuf), __buf(string_type{__a}), __wrapped(__obuf) {}
+
+    basic_syncbuf(basic_syncbuf&& __other) noexcept
+        : __mtx(std::move(__other.__mtx)), __buf(std::move(__other.__buf)),
+          __wrapped(__other.__wrapped), __emit_on_sync(__other.__emit_on_sync),
+          __needs_flush(__other.__needs_flush)
+    {
+        __other.__wrapped = nullptr;
+    }
+
+    ~basic_syncbuf()
+    {
+        _no_throw_emit();
+    }
+
+    basic_syncbuf& operator=(basic_syncbuf&& __other) noexcept
+    {
+        _no_throw_emit();
+
+        __mtx = std::move(__other.__mtx);
+        __buf = std::move(__other.__buf);
+        __wrapped = __other.__wrapped;
+        __emit_on_sync = __other.__emit_on_sync;
+        __needs_flush = __other.__needs_flush;
+
+        __other.__wrapped = nullptr;
+
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void swap(basic_syncbuf& __other)
+    {
+        std::swap(__mtx, __other.__mtx);
+        std::swap(__buf, __other.__buf);
+        std::swap(__wrapped, __other.__wrapped);
+        std::swap(__emit_on_sync, __other.__emit_on_sync);
+        std::swap(__needs_flush, __other.__needs_flush);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    bool emit()
+    {
+        if (!__wrapped)
+        {
+            return false;
+        }
+
+        // auto __view = __buf.view(); // C++20
+        // auto __str = std::move(__buf).str(); // C++20
+        decltype(__buf.str()) __str;
+        {
+            stringbuf_type __temp = std::move(__buf);
+            __str = __temp.str();
+        }
+
+        lock_guard<__mutex> __lk{__mtx};
+        if (std::streamsize __size = __str.size())
+        {
+            if (__wrapped->sputn(__str.data(), __size) != __size)
+            {
+                return false;
+            }
+        }
+
+        if (__needs_flush)
+        {
+            __needs_flush = false;
+            return !__wrapped->pubsync();
+        }
+
+        return true;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    streambuf_type* get_wrapped()   const noexcept
+    {
+        return __wrapped;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    allocator_type get_allocator() const noexcept
+    {
+        // return __buf.get_allocator(); // C++20
+        return allocator_type{};
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void set_emit_on_sync(bool __b) noexcept
+    {
+        __emit_on_sync = __b;
+    }
+
+protected:
+    _LIBCPP_HIDE_FROM_ABI
+    int sync() override
+    {
+        __needs_flush = true;
+        return !__emit_on_sync || emit() ? 0 : traits::eof();
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    streamsize xsputn(const char_type* __s, streamsize __n) override
+    {
+        return __buf.sputn(__s, __n);
+    }
+
+private:
+    _LIBCPP_HIDE_FROM_ABI
+    void _no_throw_emit() noexcept
+    {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        try
+        {
+#endif // _LIBCPP_NO_EXCEPTIONS
+            emit();
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        }
+        catch (...)
+        {
+        }
+#endif // _LIBCPP_NO_EXCEPTIONS
+    }
+
+    struct __mutex
+    {
+        inline static map<streambuf_type*, mutex> __map{};
+        mutex* __mtx;
+
+        __mutex(streambuf_type* __ptr)
+            : __mtx(std::addressof(__map[__ptr])) {}
+
+        _LIBCPP_HIDE_FROM_ABI
+        void lock()
+        {
+            __mtx->lock();
+        }
+
+        _LIBCPP_HIDE_FROM_ABI
+        void unlock()
+        {
+            __mtx->unlock();
+        }
+
+        _LIBCPP_HIDE_FROM_ABI
+        void swap(__mutex& other)
+        {
+            std::swap(__mtx, other.__mtx);
+        }
+    };
+
+    __mutex __mtx;
+    stringbuf_type __buf;
+    streambuf_type* __wrapped;
+    bool __emit_on_sync{};
+    bool __needs_flush{};
+};
+
+
+template <class charT, class traits, class Allocator>
+_LIBCPP_HIDE_FROM_ABI
+void swap(basic_syncbuf<charT, traits, Allocator>& __a,
+          basic_syncbuf<charT, traits, Allocator>& __b)
+{
+    __a.swap(__b);
+}
+
+using syncbuf = basic_syncbuf<char>;
+using wsyncbuf = basic_syncbuf<wchar_t>;
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SYNCSTREAM

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

 {'is_defined': False, 'name': '_ZTVN10__cxxabiv120__si_class_type_infoE', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVN10__cxxabiv121__vmi_class_type_infoE', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt11logic_error', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt12length_error', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt12out_of_range', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt13runtime_error', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt14overflow_error', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt16invalid_argument', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVSt9exception', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZdaPv', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_ZdaPvSt11align_val_t', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_ZdlPv', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZdlPvSt11align_val_t', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_Znam', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_ZnamSt11align_val_t', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_Znwm', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZnwmSt11align_val_t', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_allocate_exception', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_begin_catch', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_current_primary_exception', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_decrement_exception_refcount', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_end_catch', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_free_exception', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_guard_abort', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_guard_acquire', 'type': 'FUNC'}

 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5digitE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5graphE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5lowerE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5printE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5punctE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5spaceE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5upperE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base6xdigitE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110defer_lockE', 'size': 1, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110istrstreamD0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__110istrstreamD1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__110istrstreamD2Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb0EE2idE', 'size': 16, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb0EE4intlE', 'size': 1, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb1EE2idE', 'size': 16, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb1EE4intlE', 'size': 1, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb0EE2idE', 'size': 16, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb0EE4intlE', 'size': 1, 'type': 'OBJECT'}

 {'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'size': 112, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'size': 120, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__119__shared_weak_countE', 'size': 56, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__119basic_istringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'size': 80, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__119basic_ostringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'size': 80, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__120__time_get_c_storageIcEE', 'size': 72, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__120__time_get_c_storageIwEE', 'size': 72, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__14__fs10filesystem16filesystem_errorE', 'size': 40, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__15ctypeIcEE', 'size': 104, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__15ctypeIwEE', 'size': 136, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__16locale5facetE', 'size': 40, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDiDu11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDsDu11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}

 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
 No newline at end of file

libcxx/test/libcxx/double_include.sh.cpp

 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #include <string.h>
 #include <string_view>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <syncstream>
+#endif
 #include <system_error>
 #include <tgmath.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 #endif
 #include <tuple>
 #include <typeindex>
 #include <typeinfo>

libcxx/test/libcxx/input.output/stream.buffers/syncbuf/version.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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+#include <syncstream>
+
+#include "test_macros.h"
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main(int, char**)
+{
+
+  return 0;
+}

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 #include <stdlib.h>
 TEST_MACROS();
 #include <string>
 TEST_MACROS();
 #include <string.h>
 TEST_MACROS();
 #include <string_view>
 TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <syncstream>
+TEST_MACROS();
+#endif
 #include <system_error>
 TEST_MACROS();
 #include <tgmath.h>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 TEST_MACROS();
 #endif

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #include <string.h>
 #include <string_view>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <syncstream>
+#endif
 #include <system_error>
 #include <tgmath.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 #endif
 #include <tuple>
 #include <typeindex>
 #include <typeinfo>

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.assign/member_swap.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf(const basic_syncbuf& rhs); // implicitly deleted
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::stringbuf buf;
+    std::syncbuf sbuf{&buf};
+    std::syncbuf nullbuf;
+
+    assert(sbuf.get_wrapped() == &buf);
+    assert(nullbuf.get_wrapped() == nullptr);
+
+    sbuf.swap(nullbuf);
+
+    assert(sbuf.get_wrapped() == nullptr);
+    assert(nullbuf.get_wrapped() == &buf);
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf& operator=(basic_syncbuf&&);
+
+#include <syncstream>
+#include <cassert>
+
+#include <iostream>
+
+int main(int, char**)
+{
+    std::stringbuf buf;
+    {
+        std::syncbuf sbuf{&buf};
+
+        std::stringbuf buf2;
+        std::syncbuf sbuf2{&buf2};
+
+        sbuf.sputn("DEF", 3);
+        sbuf2.sputn("ABC", 3);
+        
+        assert(buf.str() == "");
+        assert(buf2.str() == "");
+
+        sbuf2 = std::move(sbuf);
+
+        assert(sbuf.get_wrapped() == nullptr);
+        assert(sbuf2.get_wrapped() == &buf);
+
+        assert(buf.str() == "");
+        assert(buf2.str() == "ABC");
+    }
+    assert(buf.str() == "DEF");
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.assign/nonmember_swap.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// template <class charT, class traits, class Allocator>
+// void swap(basic_syncbuf<charT, traits, Allocator>&,
+//           basic_syncbuf<charT, traits, Allocator>&);
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::stringbuf buf;
+    std::syncbuf sbuf{&buf};
+    std::syncbuf nullbuf;
+
+    assert(sbuf.get_wrapped() == &buf);
+    assert(nullbuf.get_wrapped() == nullptr);
+
+    std::swap(sbuf, nullbuf);
+
+    assert(sbuf.get_wrapped() == nullptr);
+    assert(nullbuf.get_wrapped() == &buf);
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.cons/allocator.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type*, const Allocator&);
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::syncbuf::allocator_type a;
+    std::syncbuf buf{nullptr, a};
+    assert(buf.get_allocator() == a);
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf(const basic_syncbuf& rhs); // implicitly deleted
+
+#include <syncstream>
+
+std::syncbuf &get();
+
+int main(int, char**)
+{
+    std::syncbuf sb = get(); // expected-error {{call to implicitly-deleted copy constructor}}
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.cons/default.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf);
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::syncbuf buf;
+    assert(buf.get_wrapped() == nullptr);
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.cons/wrapped.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf();
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::stringbuf sbuf;
+    std::syncbuf buf{&sbuf};
+    assert(buf.get_wrapped() == &sbuf);
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.members/emit.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// bool emit();
+
+#include <syncstream>
+#include <cassert>
+
+
+struct bad_sputn : public std::stringbuf
+{
+    std::streamsize xsputn(const char *, std::streamsize n) override
+    {
+        return n - 1;
+    }
+};
+
+struct bad_sync : public std::stringbuf
+{
+    int sync() override
+    {
+        return -1;
+    }
+};
+
+struct pubsync : public std::syncbuf
+{
+    using std::syncbuf::sync;
+};
+
+struct sputn_throws : public std::stringbuf
+{
+    std::streamsize xsputn(const char *, std::streamsize) override
+    {
+        throw 1;
+    }
+};
+
+int main(int, char**)
+{
+    {
+        std::stringbuf sbuf;
+        {
+            std::syncbuf buf{&sbuf};
+            buf.sputn("world", 5);
+            assert(buf.emit());
+            sbuf.sputn("Hello ", 6);
+        }
+        assert(sbuf.str() == "worldHello ");
+    }
+
+    {
+        std::syncbuf buf{nullptr};
+        assert(!buf.emit());
+    }
+
+    {
+        bad_sputn sbuf;
+        std::syncbuf buf{&sbuf};
+        buf.sputn("ABC", 3);
+        assert(!buf.emit());
+    }
+
+    {
+        bad_sync sbuf;
+        pubsync buf;
+        buf.sputn("ABC", 3);
+        buf.sync();
+        assert(!buf.emit());
+    }
+
+    try {
+        sputn_throws sbuf;
+        std::syncbuf buf{&sbuf};
+        buf.sputn("A", 1);
+    } catch(...) {
+        assert(false);
+    }
+
+    try {
+        sputn_throws sbuf;
+        std::syncbuf buf{&sbuf};
+        buf.sputn("A", 1);
+        buf.emit();
+        assert(false);
+    } catch (...) {}
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.members/emit_mt.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// bool emit();
+
+#include <syncstream>
+#include <thread>
+#include <vector>
+#include <cassert>
+
+
+static void print_chars(std::streambuf *os, int to_print)
+{
+    std::syncbuf buf{os};
+    char c = '0' + to_print;
+    for (int i = 0; i < 10; ++i) {
+        std::this_thread::yield();
+        buf.sputn(&c, 1);
+    }
+}
+
+bool all_contigous_chars(const std::string &str)
+{
+    for (auto it = str.begin(), cur_end = it + 10, end = str.end();
+            it != end; it = cur_end, cur_end += 10) {
+        if (!std::all_of(it, cur_end, [it] (auto c) { return c == *it; }))
+            return false;
+    }
+    return true;
+}
+
+int main(int, char**)
+{
+    std::stringbuf buf;
+    std::vector<std::thread> threads;
+    for (int i = 0; i < 10; ++i)
+        threads.emplace_back(print_chars, &buf, i);
+
+    for (auto &t : threads)
+        t.join();
+
+    auto str = buf.str();
+    assert(str.size() == 10 * threads.size());
+    assert(all_contigous_chars(str));
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.members/set_emit_on_sync.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// void set_emit_on_sync(bool) noexcept;
+
+#include <syncstream>
+#include <cassert>
+
+int emit_called;
+
+struct test : public std::syncbuf
+{
+
+    void emit() override
+    {
+        ++emit_called;
+    }
+
+    using std::syncbuf::sync;
+};
+
+
+int main(int, char**)
+{
+    {
+        test t;
+        t.sync();
+        assert(!emit_called);
+    }
+    {
+        test t;
+        t.set_emit_on_sync(true);
+        t.sync();
+        assert(emit_called == 1); 
+    }
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.members/sputn.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf : public basic_streambuf<charT, traits>;
+
+// From basic_streambuf<charT, traits>
+// streamsize sputn(const char_type*, streamsize);
+
+// ~basic_syncbuf();
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::stringbuf sbuf;
+    {
+        std::syncbuf buf{&sbuf};
+        buf.sputn("world", 5);
+        sbuf.sputn("Hello ", 6);
+    }
+    assert(sbuf.str() == "Hello world");
+
+  return 0;
+}

libcxx/test/std/input.output/stream.buffers/syncbuf/types.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, c++11, c++14, c++17
+
+// <syncstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_syncstream
+// {
+// public:
+//     // types:
+//     using char_type      = charT;
+//     using int_type       = typename traits::int_type;
+//     using pos_type       = typename traits::pos_type;
+//     using off_type       = typename traits::off_type;
+//     using traits_type    = traits;
+//     using allocator_type = Allocator;
+
+#include <syncstream>
+#include <type_traits>
+
+
+int main(int, char**)
+{
+    static_assert((std::is_same<std::syncbuf::char_type, char>::value), "");
+    static_assert((std::is_same<std::syncbuf::traits_type, std::char_traits<char> >::value), "");
+    static_assert((std::is_same<std::syncbuf::int_type, std::char_traits<char>::int_type>::value), "");
+    static_assert((std::is_same<std::syncbuf::pos_type, std::char_traits<char>::pos_type>::value), "");
+    static_assert((std::is_same<std::syncbuf::off_type, std::char_traits<char>::off_type>::value), "");
+    static_assert((std::is_same<std::syncbuf::traits_type, std::char_traits<char>>::value), "");
+    static_assert((std::is_same<std::syncbuf::allocator_type, std::allocator<char>>::value), "");
+
+    static_assert((std::is_same<std::wsyncbuf::char_type, wchar_t>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::traits_type, std::char_traits<wchar_t> >::value), "");
+    static_assert((std::is_same<std::wsyncbuf::int_type, std::char_traits<wchar_t>::int_type>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::pos_type, std::char_traits<wchar_t>::pos_type>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::off_type, std::char_traits<wchar_t>::off_type>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::traits_type, std::char_traits<wchar_t>>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::allocator_type, std::allocator<wchar_t>>::value), "");
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

# C++2a
     "headers": ["atomic", "memory"],
     "unimplemented": True,
     "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
    }, {
     "name": "__cpp_lib_constexpr_dynamic_alloc",
     "values": { "c++2a": int(201907) },
     "headers": ["memory"]
-   },
+   }, {
+    "name": "__cpp_lib_syncbuf",
+    "values": {"c++2a": int(201803) },
+    "headers": ["syncstream"]
+   }
 ]], key=lambda tc: tc["name"])
 
 # Map from each header to the Lit annotations that should be used for
 # tests that include that header.
 #
 # For example, when threads are not supported, any feature-test-macro test
 # that includes <thread> should be marked as UNSUPPORTED, because including
 # <thread> is a hard error in that case.