Restoring authorship annotation for Andrey Khalyavin <[email protected]>. Commit 1 of 2.

1 files changed, 328 insertions, 328 deletions

diff --git a/contrib/libs/cxxsupp/libcxx/include/experimental/coroutine b/contrib/libs/cxxsupp/libcxx/include/experimental/coroutine
index 54ec74b9f98..806e7379940 100644
--- a/contrib/libs/cxxsupp/libcxx/include/experimental/coroutine
+++ b/contrib/libs/cxxsupp/libcxx/include/experimental/coroutine
@@ -1,334 +1,334 @@
-// -*- C++ -*-
-//===----------------------------- coroutine -----------------------------===//
-//
+// -*- C++ -*- 
+//===----------------------------- coroutine -----------------------------===// 
+// 
 // 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_EXPERIMENTAL_COROUTINE
-#define _LIBCPP_EXPERIMENTAL_COROUTINE
-
-/**
-    experimental/coroutine synopsis
-
-// C++next
-
-namespace std {
-namespace experimental {
-inline namespace coroutines_v1 {
-
-  // 18.11.1 coroutine traits
-template <typename R, typename... ArgTypes>
-class coroutine_traits;
-// 18.11.2 coroutine handle
-template <typename Promise = void>
-class coroutine_handle;
-// 18.11.2.7 comparison operators:
-bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-// 18.11.3 trivial awaitables
-struct suspend_never;
-struct suspend_always;
-// 18.11.2.8 hash support:
-template <class T> struct hash;
-template <class P> struct hash<coroutine_handle<P>>;
-
-} // namespace coroutines_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <experimental/__config>
-#include <new>
-#include <type_traits>
-#include <functional>
-#include <memory> // for hash<T*>
-#include <cstddef>
-#include <__debug>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-#ifdef _LIBCPP_HAS_NO_COROUTINES
-# if defined(_LIBCPP_WARNING)
-    _LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler")
-# else
-#   warning <experimental/coroutine> cannot be used with this compiler
-# endif
-#endif
-
-#ifndef _LIBCPP_HAS_NO_COROUTINES
-
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
-
-template <class _Tp, class = void>
-struct __coroutine_traits_sfinae {};
-
-template <class _Tp>
-struct __coroutine_traits_sfinae<
-    _Tp, typename __void_t<typename _Tp::promise_type>::type>
-{
-  using promise_type = typename _Tp::promise_type;
-};
-
-template <typename _Ret, typename... _Args>
-struct coroutine_traits
-    : public __coroutine_traits_sfinae<_Ret>
-{
-};
-
-template <typename _Promise = void>
-class _LIBCPP_TEMPLATE_VIS coroutine_handle;
-
-template <>
-class _LIBCPP_TEMPLATE_VIS coroutine_handle<void> {
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR coroutine_handle() _NOEXCEPT : __handle_(nullptr) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR coroutine_handle(nullptr_t) _NOEXCEPT : __handle_(nullptr) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
-        __handle_ = nullptr;
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR void* address() const _NOEXCEPT { return __handle_; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return __handle_; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()() { resume(); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void resume() {
-      _LIBCPP_ASSERT(__is_suspended(),
-                     "resume() can only be called on suspended coroutines");
-      _LIBCPP_ASSERT(!done(),
-                "resume() has undefined behavior when the coroutine is done");
-      __builtin_coro_resume(__handle_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void destroy() {
-      _LIBCPP_ASSERT(__is_suspended(),
-                     "destroy() can only be called on suspended coroutines");
-      __builtin_coro_destroy(__handle_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool done() const {
-      _LIBCPP_ASSERT(__is_suspended(),
-                     "done() can only be called on suspended coroutines");
-      return __builtin_coro_done(__handle_);
-    }
-
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    static coroutine_handle from_address(void* __addr) _NOEXCEPT {
-        coroutine_handle __tmp;
-        __tmp.__handle_ = __addr;
-        return __tmp;
-    }
-
-    // FIXME: Should from_address(nullptr) be allowed?
-    _LIBCPP_INLINE_VISIBILITY
-    static coroutine_handle from_address(nullptr_t) _NOEXCEPT {
-      return coroutine_handle(nullptr);
-    }
-
-    template <class _Tp, bool _CallIsValid = false>
-    static coroutine_handle from_address(_Tp*) {
-      static_assert(_CallIsValid,
-       "coroutine_handle<void>::from_address cannot be called with "
-        "non-void pointers");
-    }
-
-private:
-  bool __is_suspended() const _NOEXCEPT  {
-    // FIXME actually implement a check for if the coro is suspended.
-    return __handle_;
-  }
-
-  template <class _PromiseT> friend class coroutine_handle;
-  void* __handle_;
-};
-
-// 18.11.2.7 comparison operators:
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
-    return __x.address() == __y.address();
-}
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator!=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
-    return !(__x == __y);
-}
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
-    return less<void*>()(__x.address(), __y.address());
-}
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
-    return __y < __x;
-}
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
-    return !(__x > __y);
-}
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
-    return !(__x < __y);
-}
-
-template <typename _Promise>
-class _LIBCPP_TEMPLATE_VIS coroutine_handle : public coroutine_handle<> {
-    using _Base = coroutine_handle<>;
-public:
-#ifndef _LIBCPP_CXX03_LANG
-    // 18.11.2.1 construct/reset
-    using coroutine_handle<>::coroutine_handle;
-#else
-    _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT : _Base() {}
-    _LIBCPP_INLINE_VISIBILITY coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {}
-#endif
-    _LIBCPP_INLINE_VISIBILITY
-    coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
-        _Base::operator=(nullptr);
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _Promise& promise() const {
-        return *static_cast<_Promise*>(
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef _LIBCPP_EXPERIMENTAL_COROUTINE 
+#define _LIBCPP_EXPERIMENTAL_COROUTINE 
+ 
+/** 
+    experimental/coroutine synopsis 
+ 
+// C++next 
+ 
+namespace std { 
+namespace experimental { 
+inline namespace coroutines_v1 { 
+ 
+  // 18.11.1 coroutine traits 
+template <typename R, typename... ArgTypes> 
+class coroutine_traits; 
+// 18.11.2 coroutine handle 
+template <typename Promise = void> 
+class coroutine_handle; 
+// 18.11.2.7 comparison operators: 
+bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; 
+bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; 
+bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; 
+bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; 
+bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; 
+bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT; 
+// 18.11.3 trivial awaitables 
+struct suspend_never; 
+struct suspend_always; 
+// 18.11.2.8 hash support: 
+template <class T> struct hash; 
+template <class P> struct hash<coroutine_handle<P>>; 
+ 
+} // namespace coroutines_v1 
+} // namespace experimental 
+} // namespace std 
+ 
+ */ 
+ 
+#include <experimental/__config> 
+#include <new> 
+#include <type_traits> 
+#include <functional> 
+#include <memory> // for hash<T*> 
+#include <cstddef> 
+#include <__debug> 
+ 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
+#pragma GCC system_header 
+#endif 
+ 
+#ifdef _LIBCPP_HAS_NO_COROUTINES 
+# if defined(_LIBCPP_WARNING) 
+    _LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler") 
+# else 
+#   warning <experimental/coroutine> cannot be used with this compiler 
+# endif 
+#endif 
+ 
+#ifndef _LIBCPP_HAS_NO_COROUTINES 
+ 
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES 
+ 
+template <class _Tp, class = void> 
+struct __coroutine_traits_sfinae {}; 
+ 
+template <class _Tp> 
+struct __coroutine_traits_sfinae< 
+    _Tp, typename __void_t<typename _Tp::promise_type>::type> 
+{ 
+  using promise_type = typename _Tp::promise_type; 
+}; 
+ 
+template <typename _Ret, typename... _Args> 
+struct coroutine_traits 
+    : public __coroutine_traits_sfinae<_Ret> 
+{ 
+}; 
+ 
+template <typename _Promise = void> 
+class _LIBCPP_TEMPLATE_VIS coroutine_handle; 
+ 
+template <> 
+class _LIBCPP_TEMPLATE_VIS coroutine_handle<void> { 
+public: 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR coroutine_handle() _NOEXCEPT : __handle_(nullptr) {} 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR coroutine_handle(nullptr_t) _NOEXCEPT : __handle_(nullptr) {} 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    coroutine_handle& operator=(nullptr_t) _NOEXCEPT { 
+        __handle_ = nullptr; 
+        return *this; 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR void* address() const _NOEXCEPT { return __handle_; } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return __handle_; } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    void operator()() { resume(); } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    void resume() { 
+      _LIBCPP_ASSERT(__is_suspended(), 
+                     "resume() can only be called on suspended coroutines"); 
+      _LIBCPP_ASSERT(!done(), 
+                "resume() has undefined behavior when the coroutine is done"); 
+      __builtin_coro_resume(__handle_); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    void destroy() { 
+      _LIBCPP_ASSERT(__is_suspended(), 
+                     "destroy() can only be called on suspended coroutines"); 
+      __builtin_coro_destroy(__handle_); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    bool done() const { 
+      _LIBCPP_ASSERT(__is_suspended(), 
+                     "done() can only be called on suspended coroutines"); 
+      return __builtin_coro_done(__handle_); 
+    } 
+ 
+public: 
+    _LIBCPP_INLINE_VISIBILITY 
+    static coroutine_handle from_address(void* __addr) _NOEXCEPT { 
+        coroutine_handle __tmp; 
+        __tmp.__handle_ = __addr; 
+        return __tmp; 
+    } 
+ 
+    // FIXME: Should from_address(nullptr) be allowed? 
+    _LIBCPP_INLINE_VISIBILITY 
+    static coroutine_handle from_address(nullptr_t) _NOEXCEPT { 
+      return coroutine_handle(nullptr); 
+    } 
+ 
+    template <class _Tp, bool _CallIsValid = false> 
+    static coroutine_handle from_address(_Tp*) { 
+      static_assert(_CallIsValid, 
+       "coroutine_handle<void>::from_address cannot be called with " 
+        "non-void pointers"); 
+    } 
+ 
+private: 
+  bool __is_suspended() const _NOEXCEPT  { 
+    // FIXME actually implement a check for if the coro is suspended. 
+    return __handle_; 
+  } 
+ 
+  template <class _PromiseT> friend class coroutine_handle; 
+  void* __handle_; 
+}; 
+ 
+// 18.11.2.7 comparison operators: 
+inline _LIBCPP_INLINE_VISIBILITY 
+bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { 
+    return __x.address() == __y.address(); 
+} 
+inline _LIBCPP_INLINE_VISIBILITY 
+bool operator!=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { 
+    return !(__x == __y); 
+} 
+inline _LIBCPP_INLINE_VISIBILITY 
+bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { 
+    return less<void*>()(__x.address(), __y.address()); 
+} 
+inline _LIBCPP_INLINE_VISIBILITY 
+bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { 
+    return __y < __x; 
+} 
+inline _LIBCPP_INLINE_VISIBILITY 
+bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { 
+    return !(__x > __y); 
+} 
+inline _LIBCPP_INLINE_VISIBILITY 
+bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT { 
+    return !(__x < __y); 
+} 
+ 
+template <typename _Promise> 
+class _LIBCPP_TEMPLATE_VIS coroutine_handle : public coroutine_handle<> { 
+    using _Base = coroutine_handle<>; 
+public: 
+#ifndef _LIBCPP_CXX03_LANG 
+    // 18.11.2.1 construct/reset 
+    using coroutine_handle<>::coroutine_handle; 
+#else 
+    _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT : _Base() {} 
+    _LIBCPP_INLINE_VISIBILITY coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {} 
+#endif 
+    _LIBCPP_INLINE_VISIBILITY 
+    coroutine_handle& operator=(nullptr_t) _NOEXCEPT { 
+        _Base::operator=(nullptr); 
+        return *this; 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _Promise& promise() const { 
+        return *static_cast<_Promise*>( 
             __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
-    }
-
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    static coroutine_handle from_address(void* __addr) _NOEXCEPT {
-        coroutine_handle __tmp;
-        __tmp.__handle_ = __addr;
-        return __tmp;
-    }
-
-    // NOTE: this overload isn't required by the standard but is needed so
-    // the deleted _Promise* overload doesn't make from_address(nullptr)
-    // ambiguous.
-    // FIXME: should from_address work with nullptr?
-    _LIBCPP_INLINE_VISIBILITY
-    static coroutine_handle from_address(nullptr_t) _NOEXCEPT {
-      return coroutine_handle(nullptr);
-    }
-
-    template <class _Tp, bool _CallIsValid = false>
-    static coroutine_handle from_address(_Tp*) {
-      static_assert(_CallIsValid,
-       "coroutine_handle<promise_type>::from_address cannot be called with "
-        "non-void pointers");
-    }
-
-    template <bool _CallIsValid = false>
-    static coroutine_handle from_address(_Promise*) {
-      static_assert(_CallIsValid,
-       "coroutine_handle<promise_type>::from_address cannot be used with "
-        "pointers to the coroutine's promise type; use 'from_promise' instead");
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT {
-        typedef typename remove_cv<_Promise>::type _RawPromise;
-        coroutine_handle __tmp;
-        __tmp.__handle_ = __builtin_coro_promise(
-            _VSTD::addressof(const_cast<_RawPromise&>(__promise)),
+    } 
+ 
+public: 
+    _LIBCPP_INLINE_VISIBILITY 
+    static coroutine_handle from_address(void* __addr) _NOEXCEPT { 
+        coroutine_handle __tmp; 
+        __tmp.__handle_ = __addr; 
+        return __tmp; 
+    } 
+ 
+    // NOTE: this overload isn't required by the standard but is needed so 
+    // the deleted _Promise* overload doesn't make from_address(nullptr) 
+    // ambiguous. 
+    // FIXME: should from_address work with nullptr? 
+    _LIBCPP_INLINE_VISIBILITY 
+    static coroutine_handle from_address(nullptr_t) _NOEXCEPT { 
+      return coroutine_handle(nullptr); 
+    } 
+ 
+    template <class _Tp, bool _CallIsValid = false> 
+    static coroutine_handle from_address(_Tp*) { 
+      static_assert(_CallIsValid, 
+       "coroutine_handle<promise_type>::from_address cannot be called with " 
+        "non-void pointers"); 
+    } 
+ 
+    template <bool _CallIsValid = false> 
+    static coroutine_handle from_address(_Promise*) { 
+      static_assert(_CallIsValid, 
+       "coroutine_handle<promise_type>::from_address cannot be used with " 
+        "pointers to the coroutine's promise type; use 'from_promise' instead"); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT { 
+        typedef typename remove_cv<_Promise>::type _RawPromise; 
+        coroutine_handle __tmp; 
+        __tmp.__handle_ = __builtin_coro_promise( 
+            _VSTD::addressof(const_cast<_RawPromise&>(__promise)), 
              _LIBCPP_ALIGNOF(_Promise), true);
-        return __tmp;
-    }
-};
-
-#if __has_builtin(__builtin_coro_noop)
-struct noop_coroutine_promise {};
-
-template <>
-class _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise>
-    : public coroutine_handle<> {
-  using _Base = coroutine_handle<>;
-  using _Promise = noop_coroutine_promise;
-public:
-
-  _LIBCPP_INLINE_VISIBILITY
-  _Promise& promise() const {
-    return *static_cast<_Promise*>(
+        return __tmp; 
+    } 
+}; 
+ 
+#if __has_builtin(__builtin_coro_noop) 
+struct noop_coroutine_promise {}; 
+ 
+template <> 
+class _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise> 
+    : public coroutine_handle<> { 
+  using _Base = coroutine_handle<>; 
+  using _Promise = noop_coroutine_promise; 
+public: 
+ 
+  _LIBCPP_INLINE_VISIBILITY 
+  _Promise& promise() const { 
+    return *static_cast<_Promise*>( 
       __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
-  }
-
-  _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; }
-  _LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; }
-
-  _LIBCPP_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {}
-  _LIBCPP_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {}
-  _LIBCPP_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {}
-
-private:
-  _LIBCPP_INLINE_VISIBILITY
-  friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT;
-
-  _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT {
-    this->__handle_ = __builtin_coro_noop();
-  }
-};
-
-using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
-
-inline _LIBCPP_INLINE_VISIBILITY
-noop_coroutine_handle noop_coroutine() _NOEXCEPT {
-  return noop_coroutine_handle();
-}
-#endif // __has_builtin(__builtin_coro_noop)
-
-struct suspend_never {
-  _LIBCPP_INLINE_VISIBILITY
-  bool await_ready() const _NOEXCEPT { return true; }
-  _LIBCPP_INLINE_VISIBILITY
-  void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
-  _LIBCPP_INLINE_VISIBILITY
-  void await_resume() const _NOEXCEPT {}
-};
-
-struct suspend_always {
-  _LIBCPP_INLINE_VISIBILITY
-  bool await_ready() const _NOEXCEPT { return false; }
-  _LIBCPP_INLINE_VISIBILITY
-  void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
-  _LIBCPP_INLINE_VISIBILITY
-  void await_resume() const _NOEXCEPT {}
-};
-
-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct hash<_VSTD_CORO::coroutine_handle<_Tp> > {
-    using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>;
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(__arg_type const& __v) const _NOEXCEPT
-    {return hash<void*>()(__v.address());}
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_COROUTINES)
-
-#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */
+  } 
+ 
+  _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; } 
+  _LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; } 
+ 
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {} 
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {} 
+  _LIBCPP_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {} 
+ 
+private: 
+  _LIBCPP_INLINE_VISIBILITY 
+  friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT; 
+ 
+  _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT { 
+    this->__handle_ = __builtin_coro_noop(); 
+  } 
+}; 
+ 
+using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>; 
+ 
+inline _LIBCPP_INLINE_VISIBILITY 
+noop_coroutine_handle noop_coroutine() _NOEXCEPT { 
+  return noop_coroutine_handle(); 
+} 
+#endif // __has_builtin(__builtin_coro_noop) 
+ 
+struct suspend_never { 
+  _LIBCPP_INLINE_VISIBILITY 
+  bool await_ready() const _NOEXCEPT { return true; } 
+  _LIBCPP_INLINE_VISIBILITY 
+  void await_suspend(coroutine_handle<>) const _NOEXCEPT {} 
+  _LIBCPP_INLINE_VISIBILITY 
+  void await_resume() const _NOEXCEPT {} 
+}; 
+ 
+struct suspend_always { 
+  _LIBCPP_INLINE_VISIBILITY 
+  bool await_ready() const _NOEXCEPT { return false; } 
+  _LIBCPP_INLINE_VISIBILITY 
+  void await_suspend(coroutine_handle<>) const _NOEXCEPT {} 
+  _LIBCPP_INLINE_VISIBILITY 
+  void await_resume() const _NOEXCEPT {} 
+}; 
+ 
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES 
+ 
+_LIBCPP_BEGIN_NAMESPACE_STD 
+ 
+template <class _Tp> 
+struct hash<_VSTD_CORO::coroutine_handle<_Tp> > { 
+    using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>; 
+    _LIBCPP_INLINE_VISIBILITY 
+    size_t operator()(__arg_type const& __v) const _NOEXCEPT 
+    {return hash<void*>()(__v.address());} 
+}; 
+ 
+_LIBCPP_END_NAMESPACE_STD 
+ 
+#endif // !defined(_LIBCPP_HAS_NO_COROUTINES) 
+ 
+#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */