[libc++] Remove <experimental/coroutine>

[ldionne]

Summary

We've been shipping <coroutine> since LLVM 14, so LLVM 17 won't ship
the <experimental/coroutine> header per our policy for removing TSes.

[lxfind]

My guess is you might need to keep coro in both std and std::experimental for a while, to allow smooth transition.

[ChuanqiXu]

In D108697#2965321, @lxfind wrote:

My guess is you might need to keep coro in both std and std::experimental for a while, to allow smooth transition.

In D108696, the clang would lookup in std and std::experimental namespace. And this patch would only be checked in after D108696 get checked in. So I think it wouldn't affect users much.

[lxfind]

In D108696, the clang would lookup in std and std::experimental namespace. And this patch would only be checked in after D108696 get checked in. So I think it wouldn't affect users much.

Well, but if user code has "#include <experimental/coroutine>", would it still compile?

[ChuanqiXu]

• Remain <experimental/coroutine>
• Emit a warning told the user to include <coroutine> if user included <experimental/coroutine>

[ChuanqiXu]

In D108697#2966516, @lxfind wrote:

In D108696, the clang would lookup in std and std::experimental namespace. And this patch would only be checked in after D108696 get checked in. So I think it wouldn't affect users much.

Well, but if user code has "#include <experimental/coroutine>", would it still compile?

Yes, it wouldn't compile. So in this revision, I remained the <experimental/coroutine> and add a warning directive to notice the user to include <coroutine>.
Now the user codes should be able to compile all the way after the user update either clang or libcxx. The only exception is that the user uses -Werror. It would the codes couldn't compile after updating. But I think we can't do nothing better.

[lxfind]

The warning seems redundant to the one in D108696?

[ChuanqiXu]

In D108697#2968346, @lxfind wrote:

The warning seems redundant to the one in D108696?

Yes. I considered that clang and libcxx are two different projects. So the user might update them separately. e.g., update clang only or update libcxx only. So I choose to put warning in both clang part and libcxx part. It may produce redundant warnings if the user update clang and libcxx together. But I thought that it might not be a problem.

[• Quuxplusone]

First pass. This is still presumably a step in the right direction, but it's currently far from being "C++20 conforming" and IMHO it would probably be nice to get it conforming (or close to conforming) before it lands.

libcxx/include/coroutine

47–48

Now that we're doing granular headers, please prefer to #include just the smallest helper headers possible (e.g. in this case I think all you need is <__functional/hash.h> for hash<T*>).

58–60

Remove experimental/

86

(1) I'd prefer to see __handle_ get a default member initializer on its declaration, so we don't have to member-initialize it here nor on line 89.

(2) If this codepath were limited to _LIBCPP_STD_VER > 11, then we could use constexpr throughout instead of _LIBCPP_CONSTEXPR, and noexcept instead of _NOEXCEPT. Can we do that? Should we?

107

void resume() const.
Also void operator()() const on line 104.
(yes, this smells wrong, but it's how it was standardized, according to https://eel.is/c++draft/coroutine.handle#general )

108

Grammar nit: resume() can be called only on suspended coroutines

114

void destroy() const

127

This should be marked constexpr.

133–135

Yes, it must be allowed, at least according to https://eel.is/c++draft/coroutine.handle.export.import ; but you shouldn't have this overload. Lines 126-131 above are already doing the right thing for both null and non-null pointers.

137–141

This overload looks wrong; remove it. And add a test; something like this:

std::coroutine_handle<> h1 = [...];
int *p = (int*)h1.to_address();
std::coroutine_handle<> h2 = std::coroutine_handle<>::from_address(p);

154

Use stablenames throughout: e.g., // [coroutine.handle.compare]

155–160

Question for experts: Are we allowed to make this operator a hidden friend? If we're allowed to, then I strongly think we should make it a hidden friend.
In C++20 operator!= is not needed. (And the C++20 standard doesn't provide it.)

Ditto, C++20 specifies that operator<=> exists (and I'd like it to be a hidden friend), not the four < <= > >= operators.

179–185

Here we could just do

_LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept = default;
_LIBCPP_HIDE_FROM_ABI coroutine_handle(nullptr_t) noexcept {}

because default-constructing a _Base already has the right behavior. Right?
But actually, whoa, C++20 definitely does not permit us to make an inheritance relationship between coroutine_handle<> and coroutine_handle<Promise>! These need to be two unrelated class types.
https://eel.is/c++draft/coroutine.handle#general

205–222

Remove all of this.

[• Quuxplusone]

libcxx/include/coroutine

238

This inheritance relationship shouldn't be here.
https://eel.is/c++draft/support.coroutine#coroutine.noop

285–290

Nits:

template <class _Tp>
struct hash<coroutine_handle<_Tp> > {
  _LIBCPP_HIDE_FROM_ABI
  size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept { return hash<void*>()(__v.address()); }
};

296

Nit: // not /* (compare to some other header for consistency)

libcxx/test/libcxx/language.support/support.coroutines/version.pass.cpp

20

This file is autogenerated; you shouldn't change its whitespace.
(In general, you should ignore clang-format's wibbling and just follow existing style.)

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp

55

Undo this whitespace change.

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp

30–33

This test will have to change, since all of these are conforming C++20 and shouldn't be erroring.

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp

51–52

You added some extra spaces here; remove them. (Ditto in several other test files.)

libcxx/utils/generate_header_tests.py

53

a-z plz

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

362

a-z plz; but also, what is this file? I've never seen it before and we (libc++) definitely haven't been maintaining it. For example, it's missing headers like "concepts" and "compare" and "ranges". But it has "semaphore", so it's not just C++17 stuff... What is this?

[ChuanqiXu]

In D108697#2988135, @Quuxplusone wrote:

First pass. This is still presumably a step in the right direction, but it's currently far from being "C++20 conforming" and IMHO it would probably be nice to get it conforming (or close to conforming) before it lands.

Many thanks for the detailed review! It looks like we need to refactor the implementation for <coroutine> from your comments. I would try to send another patch if possible.
Then it looks like that there is a phase called 'confirming' for c++ features, right? What's that and what does that mean? Is there any documentation?

[• Quuxplusone]

Then it looks like that there is a phase called 'confirming' for c++ features, right?

No, I said "conforming," as in "make sure our implementation is conforming to the ISO C++20 Standard."
The documentation/specification of what <coroutine> should look like is primarily the standard:
http://eel.is/c++draft/support.coroutine
and secondarily (but sometimes more user-friendly-ly) cppreference:
https://en.cppreference.com/w/cpp/header/coroutine

As for the steps or phases of the political process here, there's only one step: get @ldionne to mark this PR as "accepted." :)

[ChuanqiXu]

In D108697#2988483, @Quuxplusone wrote:

Then it looks like that there is a phase called 'confirming' for c++ features, right?

No, I said "conforming," as in "make sure our implementation is conforming to the ISO C++20 Standard."
The documentation/specification of what <coroutine> should look like is primarily the standard:
http://eel.is/c++draft/support.coroutine
and secondarily (but sometimes more user-friendly-ly) cppreference:
https://en.cppreference.com/w/cpp/header/coroutine

As for the steps or phases of the political process here, there's only one step: get @ldionne to mark this PR as "accepted." :)

Got it. Although I didn't touch libcxx before, I am willing to refactor this. Thanks : )

[ldionne]

As I explained in D109433, we don't need to "move" the header. What we normally do is introduce the <coroutine> header that contains the C++20 conforming implementation without touching <experimental/coroutine>. Then, after 2 releases (LLVM 16), we remove <experimental/coroutine> altogether. I suggest that

1. D109433 is used to check-in a conforming <coroutine> implementation, and
2. This patch is repurposed to remove <experimental/coroutine> altogether. Once that's the case, this patch can sleep for two releases and I'll rebase + merge it as soon as LLVM 15 is shipped (to make sure it makes it into LLVM 16).

[ChuanqiXu]

Address @ldionne 's comments.

[ChuanqiXu]

According @ldionne's plan, this patch would sleep 2 releases.

[ldionne]

Thanks for repurposing the patch. I'm going to commandeer it to make a few tweaks and I'll keep an eye on this to ship it once we've shipped <coroutine> for two releases.

[ldionne]

Things I've done to your patch (just so you know for the future):

1. Run libcxx-generate-files. More generally, please look at https://libcxx.llvm.org/Contributing.html.
2. Remove <experimental/coroutine> from the module map.
3. Don't mention <coroutine> in libcxx/utils/generate_header_tests.py -- that belongs to the patch that will add <coroutine> proper.

[ChuanqiXu]

Thanks for taking an eye on this!

[ChuanqiXu]

@ldionne hi, @Quuxplusone mentioned that <coroutine> would only work under C++20, while there are people who use C++17/C++14 and -fcoroutines-ts combination in practice now. It implies that they have to upgrade to c++20 if they update the libcxx with <experimental/coroutine> removed. I am wondering if this is OK? Or do we need to remove <experimental/coroutine> later? (I guess it would be really long time until the primary user update to C++20.)

[ldionne]

In D108697#3205928, @ChuanqiXu wrote:

@ldionne hi, @Quuxplusone mentioned that <coroutine> would only work under C++20, while there are people who use C++17/C++14 and -fcoroutines-ts combination in practice now. It implies that they have to upgrade to c++20 if they update the libcxx with <experimental/coroutine> removed. I am wondering if this is OK? Or do we need to remove <experimental/coroutine> later? (I guess it would be really long time until the primary user update to C++20.)

We have a policy of removing TSes two releases after we ship the "real" feature. If someone has been writing production code against something in std::experimental, they need to be ready to upgrade. So, generally speaking, my stance here would be that these users indeed need to move to C++20 an adopt the real feature. In practice, we can try to accommodate some users by keeping it around for a bit longer, but I wouldn't do that unless someone explicitly requests it and can provide a justification + timeline for moving off. At the end of the day, keeping the experimental version around is not good for anyone, it just delays work that needs to happen nonetheless.

Also note that one thing we should look into is guarding uses of any experimental feature with some compiler flag like -fexperimental, which would be documented to make it clear that production code is not to be written with that flag enabled. That would make the contract between us and our users more clear.

[ChuanqiXu]

In D108697#3212560, @ldionne wrote:

In D108697#3205928, @ChuanqiXu wrote:

@ldionne hi, @Quuxplusone mentioned that <coroutine> would only work under C++20, while there are people who use C++17/C++14 and -fcoroutines-ts combination in practice now. It implies that they have to upgrade to c++20 if they update the libcxx with <experimental/coroutine> removed. I am wondering if this is OK? Or do we need to remove <experimental/coroutine> later? (I guess it would be really long time until the primary user update to C++20.)

We have a policy of removing TSes two releases after we ship the "real" feature. If someone has been writing production code against something in std::experimental, they need to be ready to upgrade. So, generally speaking, my stance here would be that these users indeed need to move to C++20 an adopt the real feature. In practice, we can try to accommodate some users by keeping it around for a bit longer, but I wouldn't do that unless someone explicitly requests it and can provide a justification + timeline for moving off. At the end of the day, keeping the experimental version around is not good for anyone, it just delays work that needs to happen nonetheless.

Also note that one thing we should look into is guarding uses of any experimental feature with some compiler flag like -fexperimental, which would be documented to make it clear that production code is not to be written with that flag enabled. That would make the contract between us and our users more clear.

Got it. If there is already a policy about this, I have no problem.

[ldionne]

Rebase onto main

[ldionne]

Remove the -fcoroutines-ts Lit feature

[ldionne]

Remove parent revision and rebase to trigger CI properly.

[ChuanqiXu]

Maybe we need to land this soon since the release/15.x branch would be created in July 26: https://discourse.llvm.org/t/llvm-15-0-0-release-schedule/63495

[philnik]

In D108697#3627549, @ChuanqiXu wrote:

Maybe we need to land this soon since the release/15.x branch would be created in July 26: https://discourse.llvm.org/t/llvm-15-0-0-release-schedule/63495

You're one release early. Your coroutine patch was part of LLVM 14, so <experimental/coroutine> stays for 14 and 15. It will be removed during the LLVM 16 timeframe.

[ChuanqiXu]

In D108697#3627713, @philnik wrote:

In D108697#3627549, @ChuanqiXu wrote:

Maybe we need to land this soon since the release/15.x branch would be created in July 26: https://discourse.llvm.org/t/llvm-15-0-0-release-schedule/63495

You're one release early. Your coroutine patch was part of LLVM 14, so <experimental/coroutine> stays for 14 and 15. It will be removed during the LLVM 16 timeframe.

Oh, I made a mistake. My bad. Thanks for clarifying.

[ldionne]

Rebase onto main.

[ldionne]

Add release note.

[ldionne]

Rebase onto main

[ldionne]

Rebase and fix some CI issues

[ldionne]

Trigger CI

[ldionne]

Regenerate files properly

[ldionne]

@aaron.ballman I seem to recall that we had spoken about delaying this for one more release while Clang was deprecating its -fcoroutines-ts flag. Do you remember that or did the holidays mess with my brain?

Otherwise, I guess the next step here would be to post an announcement on Discourse and land this -- but I think it makes sense to coordinate with Clang since that will essentially break the -fcoroutines-ts flag.

[ChuanqiXu]

In D108697#4040079, @ldionne wrote:

@aaron.ballman I seem to recall that we had spoken about delaying this for one more release while Clang was deprecating its -fcoroutines-ts flag. Do you remember that or did the holidays mess with my brain?

Otherwise, I guess the next step here would be to post an announcement on Discourse and land this -- but I think it makes sense to coordinate with Clang since that will essentially break the -fcoroutines-ts flag.

Clang haven't started to deprecate -fcoroutines-ts. We plan to deprecate -fcoroutines-ts. The discussion is in https://github.com/llvm/llvm-project/issues/59110. And the discussion looks not related to <experimental/coroutine>. So I think it is OK to remove the <experimental/coroutine> as expected now. Then we can add a warning for -fcoroutines-ts in clang otherwise we might need to do some additional works for the test of <experimental/coroutine>.

[aaron.ballman]

In D108697#4040079, @ldionne wrote:

@aaron.ballman I seem to recall that we had spoken about delaying this for one more release while Clang was deprecating its -fcoroutines-ts flag. Do you remember that or did the holidays mess with my brain?

Otherwise, I guess the next step here would be to post an announcement on Discourse and land this -- but I think it makes sense to coordinate with Clang since that will essentially break the -fcoroutines-ts flag.

We talked about removing -fcoroutines-ts for Clang 16 in https://github.com/llvm/llvm-project/issues/59110, but we didn't really talk about the experimental header except to say that some folks want to set the expectation experimental headers can be removed at any time. Personally, I think we want to be more user-friendly and give users at least a one release window to react to changes (this makes upgrading versions of Clang a bit easier because the problem to be fixed isn't a stop-the-world issue that prevents you from finding further surprises). To me, that should apply to command line flags as well as header files because removing either one causes a stop-the-world problem. Would it make sense to have one libc++ release with a deprecation warning when you include the header along with the command line flag deprecation warning? Or are you ready to be done with this header? :-)

(Speaking of the command line flag deprecation warning, is that something you're working on @ChuanqiXu? If not, I can put something together pretty quickly before the Clang 16 branch.)

[ChuanqiXu]

To me, that should apply to command line flags as well as header files because removing either one causes a stop-the-world problem.

It looks not bad to me to remove the header files first and keep -fcoroutines-ts flag a little bit longer. Do I misunderstand anything?

(Speaking of the command line flag deprecation warning, is that something you're working on @ChuanqiXu? If not, I can put something together pretty quickly before the Clang 16 branch.)

I haven't started to work on it. I just saw no one else is assigned and it is going to be branched. So that I assign myself to offer some labor help. Feel free to take it you would love to : )

[aaron.ballman]

In D108697#4042119, @ChuanqiXu wrote:

To me, that should apply to command line flags as well as header files because removing either one causes a stop-the-world problem.

It looks not bad to me to remove the header files first and keep -fcoroutines-ts flag a little bit longer. Do I misunderstand anything?

If the user's source code was looking for that header file, they now get a *fatal* error instead of a regular error (so all further compilation stops for that TU): https://godbolt.org/z/zzYEc46fW -- I don't see what value the command line flag adds without the header file, so maybe I'm missing something?

(Speaking of the command line flag deprecation warning, is that something you're working on @ChuanqiXu? If not, I can put something together pretty quickly before the Clang 16 branch.)

I haven't started to work on it. I just saw no one else is assigned and it is going to be branched. So that I assign myself to offer some labor help. Feel free to take it you would love to : )

I'd appreciate it if you can tackle it if you have the chance in the next week or so. I'm still trying to get caught up on reviews (just in time for the C standards meetings in a a few weeks, lol).

[ChuanqiXu]

In D108697#4043125, @aaron.ballman wrote:

In D108697#4042119, @ChuanqiXu wrote:

To me, that should apply to command line flags as well as header files because removing either one causes a stop-the-world problem.

It looks not bad to me to remove the header files first and keep -fcoroutines-ts flag a little bit longer. Do I misunderstand anything?

If the user's source code was looking for that header file, they now get a *fatal* error instead of a regular error (so all further compilation stops for that TU): https://godbolt.org/z/zzYEc46fW -- I don't see what value the command line flag adds without the header file, so maybe I'm missing something?

Yeah, it is not meaningless to have the command line option without the header file. Since many users would use clang + libstdc++. And there is no such file in libstdc++. So users would use a hacked local "standard" header file which implements something similar to <experimental/coroutine>. Here is an example: https://github.com/scylladb/seastar/blob/master/include/seastar/core/std-coroutine.hh. I know other such uses. I understand that such uses are not encouraged and it is out of the ecosystem of the big LLVM project. I just want to say that there are users who use -fcoroutines-ts without the <experimental/coroutine> in libcxx. I feel they will feel better to receive a warning for deprecating -fcoroutines-ts at first.

(Speaking of the command line flag deprecation warning, is that something you're working on @ChuanqiXu? If not, I can put something together pretty quickly before the Clang 16 branch.)

I haven't started to work on it. I just saw no one else is assigned and it is going to be branched. So that I assign myself to offer some labor help. Feel free to take it you would love to : )

I'd appreciate it if you can tackle it if you have the chance in the next week or so. I'm still trying to get caught up on reviews (just in time for the C standards meetings in a a few weeks, lol).

Got it. I'll try to make it and I'll try to note you to take it if I can't make it due to I'll take a vacation in 20th.

[ldionne]

I'd suggest we deprecate the flag and the header in LLVM 16, and remove the header and the flag in LLVM 17.

So we'd hold off with this patch until after the LLVM 16 branch (delaying by one more release).

[aaron.ballman]

In D108697#4044204, @ldionne wrote:

I'd suggest we deprecate the flag and the header in LLVM 16, and remove the header and the flag in LLVM 17.

So we'd hold off with this patch until after the LLVM 16 branch (delaying by one more release).

SGTM! Thank you for your patience while we figure this out. :-)

In D108697#4043477, @ChuanqiXu wrote:

In D108697#4043125, @aaron.ballman wrote:

I'd appreciate it if you can tackle it if you have the chance in the next week or so. I'm still trying to get caught up on reviews (just in time for the C standards meetings in a a few weeks, lol).

Got it. I'll try to make it and I'll try to note you to take it if I can't make it due to I'll take a vacation in 20th.

Thanks, I'm happy to take it over if you can't get to it before your vacation.

[ldionne]

Rebase onto main after branching for LLVM 16.

[ldionne]

@aaron.ballman Can you confirm that you are OK with shipping this now from the Clang point of view? I'm looking forward to stop carrying this review around, rebases are a bit tedious for something touching that many files!

[aaron.ballman]

In D108697#4080161, @ldionne wrote:

@aaron.ballman Can you confirm that you are OK with shipping this now from the Clang point of view? I'm looking forward to stop carrying this review around, rebases are a bit tedious for something touching that many files!

Yup, happy to see it ripped out now (I would be surprised if we get sufficient feedback on the RCs to warrant resurrecting it again, but I suppose that is a possibility).

[ldionne]

Thanks for confirming @aaron.ballman !

libcxx/CMakeLists.txt

function(cxx_add_basic_build_flags target)
   # so we end up not exporting all the symbols we should. In the future, we
   # can improve the situation by providing an explicit list of exported
   # symbols on all compilers.
   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     target_add_compile_flags_if_supported(${target} PRIVATE -fvisibility=hidden)
   endif()
 
   if (LIBCXX_CONFIGURE_IDE)
-    # This simply allows IDE to process <experimental/coroutine>
+    # This simply allows IDE to process <coroutine>
     target_add_compile_flags_if_supported(${target} PRIVATE -fcoroutines-ts)
   endif()
 
   # Let the library headers know they are currently being used to build the
   # library.
   target_compile_definitions(${target} PRIVATE -D_LIBCPP_BUILDING_LIBRARY)
 
   if (NOT LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS)

libcxx/include/CMakeLists.txt

set(files
   clocale
   cmath
   codecvt
   compare
   complex
   complex.h
   concepts
   condition_variable
+  coroutine
   csetjmp
   csignal
   cstdarg
   cstdbool
   cstddef
   cstdint
   cstdio
   cstdlib

libcxx/include/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_COROUTINE
+#define _LIBCPP_COROUTINE
+
+/**
+    coroutine synopsis
+
+// C++next
+
+namespace std {
+
+  // 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 std
+
+ */
+
+#include <__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_STD
+
+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)), _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*>(__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 {}
+};
+
+template <class _Tp>
+struct hash<_VSTD::coroutine_handle<_Tp> > {
+  using __arg_type = _VSTD::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_COROUTINE */

libcxx/include/experimental/coroutine

 #   warning <experimental/coroutine> cannot be used with this compiler
 # endif
 #endif
 
 #ifndef _LIBCPP_HAS_NO_COROUTINES
 
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
 
+#if defined(_LIBCPP_WARNING)
+_LIBCPP_WARNING("<experimental/coroutine> is deprecated and would like"
+                " to be removed in following versions. "
+                "Please include <coroutine> instead.")
+#else
+#   warning <experimental/coroutine> is deprecated and would like to be removed in following versions. Please include <coroutine> instead.
+#endif
+
 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;

libcxx/include/module.modulemap

module experimental {
     requires cplusplus11
 
     module algorithm {
       header "experimental/algorithm"
       export *
     }
      module coroutine {
       requires coroutines
-      header "experimental/coroutine"
+      header "coroutine"
       export *
     }
     module deque {
       header "experimental/deque"
       export *
     }
     module filesystem {
       header "experimental/filesystem"

libcxx/test/libcxx/double_include.sh.cpp

 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #    include <codecvt>
 #endif
 #include <compare>
 #include <complex>
 #include <complex.h>
 #include <concepts>
 #include <condition_variable>
+#if defined(__cpp_coroutines)
+#    include <coroutine>
+#endif
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>

 #include <vector>
 #include <version>
 #include <wchar.h>
 #include <wctype.h>
 
 // experimental headers
 #if __cplusplus >= 201103L
 #    include <experimental/algorithm>
-#    if defined(__cpp_coroutines)
-#        include <experimental/coroutine>
-#    endif
 #    include <experimental/deque>
 #    ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
 #        include <experimental/filesystem>
 #    endif
 #    include <experimental/forward_list>
 #    include <experimental/functional>
 #    include <experimental/iterator>
 #    include <experimental/list>

libcxx/test/libcxx/language.support/support.coroutines/dialect_support.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: fcoroutines-ts
 // ADDITIONAL_COMPILE_FLAGS: -fcoroutines-ts
 
-// A simple "breathing" test that checks that <experimental/coroutine>
+// A simple "breathing" test that checks that <coroutine>
 // can be parsed and used in all dialects, including C++03 in order to match
 // Clang's behavior.
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental::coroutines_v1;
-
-coro::suspend_always sa;
-coro::suspend_never sn;
+std::suspend_always sa;
+std::suspend_never sn;
 
 struct MyFuture {
   struct promise_type {
-    typedef coro::coroutine_handle<promise_type> HandleT;
-    coro::suspend_never initial_suspend() { return sn; }
-    coro::suspend_always final_suspend() TEST_NOEXCEPT { return sa; }
-    coro::suspend_never yield_value(int) { return sn; }
+    typedef std::coroutine_handle<promise_type> HandleT;
+    std::suspend_never initial_suspend() { return sn; }
+    std::suspend_always final_suspend() TEST_NOEXCEPT { return sa; }
+    std::suspend_never yield_value(int) { return sn; }
     MyFuture get_return_object() {
       MyFuture f(HandleT::from_promise(*this));
       return f;
     }
     void return_void() {}
     void unhandled_exception() {}
   };
   typedef promise_type::HandleT HandleT;
   MyFuture() : p() {}
   MyFuture(HandleT h) : p(h) {}
 
-  coro::coroutine_handle<promise_type> p;
+  std::coroutine_handle<promise_type> p;
 };
 
 MyFuture test_coro() {
   co_await sn;
   co_yield 42;
   co_return;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   MyFuture f = test_coro();
   while (!f.p.done())
     f.p.resume();
   f.p.destroy();
 
   return 0;
 }

libcxx/test/libcxx/language.support/support.coroutines/version.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 // REQUIRES: fcoroutines-ts
 // ADDITIONAL_COMPILE_FLAGS: -fcoroutines-ts
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION must be defined
 #endif
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }

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

 #include <complex>
 TEST_MACROS();
 #include <complex.h>
 TEST_MACROS();
 #include <concepts>
 TEST_MACROS();
 #include <condition_variable>
 TEST_MACROS();
+#if defined(__cpp_coroutines)
+#    include <coroutine>
+TEST_MACROS();
+#endif
 #include <csetjmp>
 TEST_MACROS();
 #include <csignal>
 TEST_MACROS();
 #include <cstdarg>
 TEST_MACROS();
 #include <cstdbool>
 TEST_MACROS();

 TEST_MACROS();
 #include <wctype.h>
 TEST_MACROS();
 
 // experimental headers
 #if __cplusplus >= 201103L
 #    include <experimental/algorithm>
 TEST_MACROS();
-#    if defined(__cpp_coroutines)
-#        include <experimental/coroutine>
-TEST_MACROS();
-#    endif
 #    include <experimental/deque>
 TEST_MACROS();
 #    ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
 #        include <experimental/filesystem>
 TEST_MACROS();
 #    endif
 #    include <experimental/forward_list>
 TEST_MACROS();

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

 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #    include <codecvt>
 #endif
 #include <compare>
 #include <complex>
 #include <complex.h>
 #include <concepts>
 #include <condition_variable>
+#if defined(__cpp_coroutines)
+#    include <coroutine>
+#endif
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>

 #include <vector>
 #include <version>
 #include <wchar.h>
 #include <wctype.h>
 
 // experimental headers
 #if __cplusplus >= 201103L
 #    include <experimental/algorithm>
-#    if defined(__cpp_coroutines)
-#        include <experimental/coroutine>
-#    endif
 #    include <experimental/deque>
 #    ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
 #        include <experimental/filesystem>
 #    endif
 #    include <experimental/forward_list>
 #    include <experimental/functional>
 #    include <experimental/iterator>
 #    include <experimental/list>

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // namespace std {
-//  template <class P> struct hash<experimental::coroutine_handle<P>>;
+//  template <class P> struct hash<coroutine_handle<P>>;
 // }
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   const size_t ExpectLHS = std::hash<void*>{}(reinterpret_cast<void*>(LHSVal));
   const size_t ExpectRHS = std::hash<void*>{}(reinterpret_cast<void*>(RHSVal));
   const C LHS = C::from_address(reinterpret_cast<void*>(LHSVal));
   const C RHS = C::from_address(reinterpret_cast<void*>(RHSVal));
   const std::hash<C> h;
   // FIXME: libc++'s implementation hash's the result of LHS.address(), so we
   // expect that value. However this is not required.
   assert(h(LHS) == ExpectLHS);
   assert(h(RHS) == ExpectRHS);
   assert((h(LHS) == h(RHS)) == (LHSVal == RHSVal));
   {
     ASSERT_SAME_TYPE(decltype(h(LHS)), size_t);
     ASSERT_NOEXCEPT(std::hash<C>{}(LHS));
   }
 }
 
-int main(int, char**)
-{
-  std::pair<uintptr_t, uintptr_t> const TestCases[] = {
-      {0, 0},
-      {0, 8},
-      {8, 8},
-      {8, 16}
-  };
+int main(int, char**) {
+  std::pair<uintptr_t, uintptr_t> const TestCases[] = {{0, 0}, {0, 8}, {8, 8}, {8, 16}};
   for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
+    do_test<std::coroutine_handle<> >(TC.first, TC.second);
+    do_test<std::coroutine_handle<int> >(TC.first, TC.second);
   }
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr explicit operator bool() const noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   static_assert(std::is_nothrow_constructible<bool, C>::value, "");
   static_assert(!std::is_convertible<C, bool>::value, "");
   {
-    constexpr C c; ((void)c);
+    constexpr C c;
+    ((void)c);
     static_assert(bool(c) == false, "");
   }
   { // null case
-    const C c = {}; ((void)c);
+    const C c = {};
+    ((void)c);
     ASSERT_NOEXCEPT(bool(c));
     if (c)
       assert(false);
     else
       assert(true);
     assert(c.address() == nullptr);
     assert(bool(c) == false);
   }
   { // non-null case
     char dummy = 42;
     C c = C::from_address((void*)&dummy);
     assert(c.address() == &dummy);
     assert(bool(c) == true);
   }
 }
 
-int main(int, char**)
-{
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+int main(int, char**) {
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // bool operator==(coroutine_handle<>, coroutine_handle<>) noexcept
 // bool operator!=(coroutine_handle<>, coroutine_handle<>) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   const C LHS = C::from_address(reinterpret_cast<void*>(LHSVal));
   const C RHS = C::from_address(reinterpret_cast<void*>(RHSVal));
   const bool ExpectIsEqual = (LHSVal == RHSVal);
   assert((LHS == RHS) == ExpectIsEqual);
   assert((RHS == LHS) == ExpectIsEqual);
   assert((LHS != RHS) == !ExpectIsEqual);
   assert((RHS != LHS) == !ExpectIsEqual);
   {
     static_assert(noexcept(LHS == RHS), "");
     static_assert(noexcept(LHS != RHS), "");
     ASSERT_SAME_TYPE(decltype(LHS == RHS), bool);
     ASSERT_SAME_TYPE(decltype(LHS != RHS), bool);
   }
 }
 
-int main(int, char**)
-{
-  std::pair<uintptr_t, uintptr_t> const TestCases[] = {
-      {0, 0},
-      {16, 16},
-      {0, 16},
-      {16, 0}
-  };
+int main(int, char**) {
+  std::pair<uintptr_t, uintptr_t> const TestCases[] = {{0, 0}, {16, 16}, {0, 16}, {16, 0}};
   for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
+    do_test<std::coroutine_handle<> >(TC.first, TC.second);
+    do_test<std::coroutine_handle<int> >(TC.first, TC.second);
   }
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // bool operator<(coroutine_handle<>, coroutine_handle<>) noexcept
 // bool operator>(coroutine_handle<>, coroutine_handle<>) noexcept
 // bool operator>=(coroutine_handle<>, coroutine_handle<>) noexcept
 // bool operator<=(coroutine_handle<>, coroutine_handle<>) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   const C LHS = C::from_address(reinterpret_cast<void*>(LHSVal));
   const C RHS = C::from_address(reinterpret_cast<void*>(RHSVal));
   assert((LHS < RHS) == (LHSVal < RHSVal));
   assert((RHS < LHS) == (RHSVal < LHSVal));
   assert((LHS > RHS) == (LHSVal > RHSVal));
   assert((RHS > LHS) == (RHSVal > LHSVal));
   assert((LHS <= RHS) == (LHSVal <= RHSVal));
   assert((RHS <= LHS) == (RHSVal <= LHSVal));
   assert((LHS >= RHS) == (LHSVal >= RHSVal));
   assert((RHS >= LHS) == (RHSVal >= LHSVal));
   {
     static_assert(noexcept(LHS < RHS), "");
     static_assert(noexcept(LHS > RHS), "");
     static_assert(noexcept(LHS <= RHS), "");
     static_assert(noexcept(LHS >= RHS), "");
     ASSERT_SAME_TYPE(decltype(LHS < RHS), bool);
     ASSERT_SAME_TYPE(decltype(LHS > RHS), bool);
     ASSERT_SAME_TYPE(decltype(LHS <= RHS), bool);
     ASSERT_SAME_TYPE(decltype(LHS >= RHS), bool);
   }
 }
 
-int main(int, char**)
-{
-  std::pair<uintptr_t, uintptr_t> const TestCases[] = {
-      {0, 0},
-      {16, 16},
-      {0, 16},
-      {16, 0}
-  };
+int main(int, char**) {
+  std::pair<uintptr_t, uintptr_t> const TestCases[] = {{0, 0}, {16, 16}, {0, 16}, {16, 0}};
   for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
+    do_test<std::coroutine_handle<> >(TC.first, TC.second);
+    do_test<std::coroutine_handle<int> >(TC.first, TC.second);
   }
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // bool done() const
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class Promise>
-void do_test(coro::coroutine_handle<Promise> const& H) {
+void do_test(std::coroutine_handle<Promise> const& H) {
   // FIXME Add a runtime test
   {
     ASSERT_SAME_TYPE(decltype(H.done()), bool);
     LIBCPP_ASSERT_NOT_NOEXCEPT(H.done());
   }
 }
 
-int main(int, char**)
-{
-  do_test(coro::coroutine_handle<>{});
-  do_test(coro::coroutine_handle<int>{});
+int main(int, char**) {
+  do_test(std::coroutine_handle<>{});
+  do_test(std::coroutine_handle<int>{});
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // coroutine_handle& operator=(nullptr_t) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   int dummy = 42;
   void* dummy_h = &dummy;
   {
-    C c; ((void)c);
+    C c;
+    ((void)c);
     static_assert(std::is_nothrow_assignable<C&, std::nullptr_t>::value, "");
     static_assert(!std::is_assignable<C&, void*>::value, "");
   }
   {
     C c = C::from_address(dummy_h);
     assert(c.address() == &dummy);
     c = nullptr;
     assert(c.address() == nullptr);
     c = nullptr;
     assert(c.address() == nullptr);
   }
   {
     C c;
     C& cr = (c = nullptr);
     assert(&c == &cr);
   }
 }
 
-int main(int, char**)
-{
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+int main(int, char**) {
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr coroutine_handle() noexcept
 // constexpr coroutine_handle(nullptr_t) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   {
     constexpr C c;
     static_assert(std::is_nothrow_default_constructible<C>::value, "");
     static_assert(c.address() == nullptr, "");
   }
   {
     constexpr C c(nullptr);
     static_assert(std::is_nothrow_constructible<C, std::nullptr_t>::value, "");
     static_assert(c.address() == nullptr, "");
   }
   {
     C c;
     assert(c.address() == nullptr);
   }
   {
     C c(nullptr);
     assert(c.address() == nullptr);
   }
 }
 
-int main(int, char**)
-{
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+int main(int, char**) {
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr void* address() const noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   {
-    constexpr C c; ((void)c);
+    constexpr C c;
+    ((void)c);
     static_assert(c.address() == nullptr, "");
   }
   {
-    const C c = {}; ((void)c);
+    const C c = {};
+    ((void)c);
     ASSERT_NOEXCEPT(c.address());
     ASSERT_SAME_TYPE(decltype(c.address()), void*);
     assert(c.address() == nullptr);
   }
   {
     char dummy = 42;
     C c = C::from_address((void*)&dummy);
     assert(c.address() == &dummy);
   }
 }
 
-int main(int, char**)
-{
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+int main(int, char**) {
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // static coroutine_handle from_address(void*) noexcept
 
 // Test that `from_address` is explicitly ill-formed when called with a typed
 // pointer. The user cannot possibly have a typed pointer to the coroutine.
 // FIXME: This behavior is an extension, and should upstreamed into the TS or
 // the test removed if the TS changes are rejected.
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
-namespace coro = std::experimental;
-
-int main(int, char**)
-{
+int main(int, char**) {
   {
-    using H = coro::coroutine_handle<>;
-    // expected-error@experimental/coroutine:* 3 {{coroutine_handle<void>::from_address cannot be called with non-void pointers}}
-    H::from_address((int*)nullptr); // expected-note {{requested here}}
+    using H = std::coroutine_handle<>;
+    // expected-error@coroutine:* 3 {{coroutine_handle<void>::from_address cannot be called with non-void pointers}}
+    H::from_address((int*)nullptr);        // expected-note {{requested here}}
     H::from_address((const void*)nullptr); // expected-note {{requested here}}
     H::from_address((const char*)nullptr); // expected-note {{requested here}}
   }
   {
-    using H = coro::coroutine_handle<int>;
-    // expected-error@experimental/coroutine:* 1 {{static_assert failed "coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead"}}
+    using H = std::coroutine_handle<int>;
+    // expected-error@coroutine:* 1 {{static_assert failed "coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead"}}
     H::from_address((const char*)nullptr); // expected-note {{requested here}}
-    // expected-error@experimental/coroutine:* 1 {{coroutine_handle<promise_type>::from_address cannot be called with non-void pointers}}
+    // expected-error@coroutine:* 1 {{coroutine_handle<promise_type>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
   }
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // static coroutine_handle from_address(void*) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   {
     C c = C::from_address(nullptr);
     static_assert(noexcept(C::from_address(nullptr)), "");
     // FIXME: Should the return type not be 'C'?
     static_assert(std::is_same<decltype(C::from_address(nullptr)), C>::value, "");
     assert(c.address() == nullptr);
   }
   {
     char dummy = 42;
     C c = C::from_address((void*)&dummy);
     assert(c.address() == &dummy);
   }
 }
 
-int main(int, char**)
-{
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+int main(int, char**) {
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 // UNSUPPORTED: ubsan
 
-// <experimental/coroutine>
+// <coroutine>
 // struct noop_coroutine_promise;
 // using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
 // noop_coroutine_handle noop_coroutine() noexcept;
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 
 #if __has_builtin(__builtin_coro_noop)
 
-namespace coro = std::experimental::coroutines_v1;
-
-
-static_assert(std::is_same<coro::coroutine_handle<coro::noop_coroutine_promise>, coro::noop_coroutine_handle>::value, "");
-static_assert(std::is_same<decltype(coro::noop_coroutine()), coro::noop_coroutine_handle>::value, "");
+static_assert(std::is_same<std::coroutine_handle<std::noop_coroutine_promise>, std::noop_coroutine_handle>::value, "");
+static_assert(std::is_same<decltype(std::noop_coroutine()), std::noop_coroutine_handle>::value, "");
 
 // template <> struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<>
 // {
 // // 18.11.2.7 noop observers
 // constexpr explicit operator bool() const noexcept;
 // constexpr bool done() const noexcept;
 
 // // 18.11.2.8 noop resumption
 // constexpr void operator()() const noexcept;
 // constexpr void resume() const noexcept;
 // constexpr void destroy() const noexcept;
 
 // // 18.11.2.9 noop promise access
 // noop_coroutine_promise& promise() const noexcept;
 
 // // 18.11.2.10 noop address
 // constexpr void* address() const noexcept;
 
-int main(int, char**)
-{
-  auto h = coro::noop_coroutine();
-  coro::coroutine_handle<> base = h;
+int main(int, char**) {
+  auto h = std::noop_coroutine();
+  std::coroutine_handle<> base = h;
 
   assert(h);
   assert(base);
 
   assert(!h.done());
   assert(!base.done());
 
   h.resume();
   h.destroy();
   h();
   static_assert(h.done() == false, "");
   static_assert(h, "");
 
   h.promise();
   assert(h.address() == base.address());
   assert(h.address() != nullptr);
-  assert(coro::coroutine_handle<>::from_address(h.address()) == base);
+  assert(std::coroutine_handle<>::from_address(h.address()) == base);
 
   return 0;
 }
 
 #else
 
 int main(int, char**) { return 0; }
 
 #endif //  __has_builtin(__builtin_coro_noop)

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise>
 // struct coroutine_handle<Promise>;
 
 // Promise& promise() const
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 struct MyCoro {
   struct promise_type {
     void unhandled_exception() {}
     void return_void() {}
-    coro::suspend_never initial_suspend() { return {}; }
-    coro::suspend_never final_suspend() noexcept { return {}; }
+    std::suspend_never initial_suspend() { return {}; }
+    std::suspend_never final_suspend() noexcept { return {}; }
     MyCoro get_return_object() {
       do_runtime_test();
       return {};
     }
     void do_runtime_test() {
       // Test that a coroutine_handle<const T> can be created from a const
       // promise_type and that it represents the same coroutine as
       // coroutine_handle<T>
-      using CH = coro::coroutine_handle<promise_type>;
-      using CCH = coro::coroutine_handle<const promise_type>;
-      const auto &cthis = *this;
+      using CH = std::coroutine_handle<promise_type>;
+      using CCH = std::coroutine_handle<const promise_type>;
+      const auto& cthis = *this;
       CH h = CH::from_promise(*this);
       CCH h2 = CCH::from_promise(*this);
       CCH h3 = CCH::from_promise(cthis);
       assert(&h.promise() == this);
       assert(&h2.promise() == this);
       assert(&h3.promise() == this);
       assert(h.address() == h2.address());
       assert(h2.address() == h3.address());
     }
   };
 };
 
-MyCoro do_runtime_test() {
-  co_await coro::suspend_never{};
-}
+MyCoro do_runtime_test() { co_await std::suspend_never{}; }
 
 template <class Promise>
-void do_test(coro::coroutine_handle<Promise>&& H) {
+void do_test(std::coroutine_handle<Promise>&& H) {
 
   // FIXME Add a runtime test
   {
     ASSERT_SAME_TYPE(decltype(H.promise()), Promise&);
     LIBCPP_ASSERT_NOT_NOEXCEPT(H.promise());
   }
   {
     auto const& CH = H;
     ASSERT_SAME_TYPE(decltype(CH.promise()), Promise&);
     LIBCPP_ASSERT_NOT_NOEXCEPT(CH.promise());
   }
 }
 
-int main(int, char**)
-{
-  do_test(coro::coroutine_handle<int>{});
-  do_test(coro::coroutine_handle<const int>{});
+int main(int, char**) {
+  do_test(std::coroutine_handle<int>{});
+  do_test(std::coroutine_handle<const int>{});
   do_runtime_test();
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // void destroy()
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class H>
 auto has_destroy_imp(H&& h, int) -> decltype(h.destroy(), std::true_type{});
 template <class H>
 auto has_destroy_imp(H&&, long) -> std::false_type;
 
 template <class H>
 constexpr bool has_destroy() {
   return decltype(has_destroy_imp(std::declval<H>(), 0))::value;
 }
 
 template <class Promise>
-void do_test(coro::coroutine_handle<Promise>&& H) {
-  using HType = coro::coroutine_handle<Promise>;
+void do_test(std::coroutine_handle<Promise>&& H) {
+  using HType = std::coroutine_handle<Promise>;
   // FIXME Add a runtime test
   {
     ASSERT_SAME_TYPE(decltype(H.destroy()), void);
     LIBCPP_ASSERT_NOT_NOEXCEPT(H.destroy());
     static_assert(has_destroy<HType&>(), "");
     static_assert(has_destroy<HType&&>(), "");
   }
   {
     static_assert(!has_destroy<HType const&>(), "");
     static_assert(!has_destroy<HType const&&>(), "");
   }
 }
 
-int main(int, char**)
-{
-  do_test(coro::coroutine_handle<>{});
-  do_test(coro::coroutine_handle<int>{});
+int main(int, char**) {
+  do_test(std::coroutine_handle<>{});
+  do_test(std::coroutine_handle<int>{});
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // void operator()()
 // void resume()
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
-
 template <class H>
 auto has_resume_imp(H&& h, int) -> decltype(h.resume(), std::true_type{});
 template <class H>
 auto has_resume_imp(H&&, long) -> std::false_type;
 
 template <class H>
 constexpr bool has_resume() {
   return decltype(has_resume_imp(std::declval<H>(), 0))::value;
 }
 
-
 template <class H>
 auto has_call_operator_imp(H&& h, int) -> decltype(h(), std::true_type{});
 template <class H>
 auto has_call_operator_imp(H&&, long) -> std::false_type;
 
 template <class H>
 constexpr bool has_call_operator() {
   return decltype(has_call_operator_imp(std::declval<H>(), 0))::value;
 }
 
 template <class Promise>
-void do_test(coro::coroutine_handle<Promise>&& H) {
-  using HType = coro::coroutine_handle<Promise>;
+void do_test(std::coroutine_handle<Promise>&& H) {
+  using HType = std::coroutine_handle<Promise>;
   // FIXME Add a runtime test
   {
     ASSERT_SAME_TYPE(decltype(H.resume()), void);
     ASSERT_SAME_TYPE(decltype(H()), void);
     LIBCPP_ASSERT_NOT_NOEXCEPT(H.resume());
     LIBCPP_ASSERT_NOT_NOEXCEPT(H());
     static_assert(has_resume<HType&>(), "");
     static_assert(has_resume<HType&&>(), "");
     static_assert(has_call_operator<HType&>(), "");
     static_assert(has_call_operator<HType&&>(), "");
   }
   {
     static_assert(!has_resume<HType const&>(), "");
     static_assert(!has_resume<HType const&&>(), "");
     static_assert(!has_call_operator<HType const&>(), "");
     static_assert(!has_call_operator<HType const&&>(), "");
   }
 }
 
-int main(int, char**)
-{
-  do_test(coro::coroutine_handle<>{});
-  do_test(coro::coroutine_handle<int>{});
+int main(int, char**) {
+  do_test(std::coroutine_handle<>{});
+  do_test(std::coroutine_handle<int>{});
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 struct A {
   using promise_type = A*;
 };
 
 struct B {};
 struct C {};
 
-namespace std { namespace experimental {
-  template <>
-  struct coroutine_traits<::A, int> {
-    using promise_type = int*;
-  };
-  template <class ...Args>
-  struct coroutine_traits<::B, Args...> {
-    using promise_type = B*;
-  };
-  template <>
-  struct coroutine_traits<::C> {
-    using promise_type = void;
-  };
-}}
+namespace std {
+struct coroutine_traits< ::A, int> {
+template <class... Args>
+struct coroutine_traits< ::B, Args...> {
+struct coroutine_traits< ::C> {
+} // namespace std
 
-template <class Expect, class T, class ...Args>
+template <class Expect, class T, class... Args>
 void check_type() {
-  using P = typename coro::coroutine_traits<T, Args...>::promise_type ;
+  using P = typename std::coroutine_traits<T, Args...>::promise_type;
   static_assert(std::is_same<P, Expect>::value, "");
 };
 
-int main(int, char**)
-{
+int main(int, char**) {
   check_type<A*, A>();
   check_type<int*, A, int>();
   check_type<B*, B>();
   check_type<void, C>();
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class T, class = typename T::promise_type>
-constexpr bool has_promise_type(int) { return true; }
+constexpr bool has_promise_type(int) {
+  return true;
+}
 template <class>
-constexpr bool has_promise_type(long) { return false; }
+constexpr bool has_promise_type(long) {
+  return false;
+}
 template <class T>
-constexpr bool has_promise_type() { return has_promise_type<T>(0); }
+constexpr bool has_promise_type() {
+  return has_promise_type<T>(0);
+}
 
 struct A {
   using promise_type = A*;
 };
 
 struct B {};
 struct C {};
 struct D {
 private:
   using promise_type = void;
 };
 struct E {};
 
-namespace std { namespace experimental {
-  template <>
-  struct coroutine_traits<::A, int> {
-    using promise_type = int*;
-  };
-  template <class ...Args>
-  struct coroutine_traits<::B, Args...> {
-    using promise_type = B*;
-  };
-  template <>
-  struct coroutine_traits<::C> {
-    using promise_type = void;
-  };
-}}
+namespace std {
+struct coroutine_traits< ::A, int> {
+template <class... Args>
+struct coroutine_traits< ::B, Args...> {
+struct coroutine_traits< ::C> {
+} // namespace std
 
-template <class Expect, class T, class ...Args>
+template <class Expect, class T, class... Args>
 void check_type() {
-  using Traits = coro::coroutine_traits<T, Args...>;
+  using Traits = std::coroutine_traits<T, Args...>;
   static_assert(has_promise_type<Traits>(), "");
   static_assert(std::is_same<typename Traits::promise_type, Expect>::value, "");
 }
 
-template <class T, class ...Args>
+template <class T, class... Args>
 void check_no_type() {
-  using Traits = coro::coroutine_traits<T, Args...>;
+  using Traits = std::coroutine_traits<T, Args...>;
   static_assert(!has_promise_type<Traits>(), "");
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   {
     check_type<A*, A>();
     check_type<int*, A, int>();
     check_type<B*, B>();
     check_type<void, C>();
   }
   {
     check_no_type<D>();
     check_no_type<E>();
     check_no_type<C, int>();
   }
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
-using SuspendT = std::experimental::coroutines_v1::suspend_always;
+using SuspendT = std::suspend_always;
 
 TEST_SAFE_STATIC SuspendT safe_sa;
 constexpr SuspendT constexpr_sa;
 
 constexpr bool check_suspend_constexpr() {
   SuspendT s{};
-  const SuspendT scopy(s); ((void)scopy);
-  SuspendT smove(std::move(s)); ((void)smove);
+  const SuspendT scopy(s);
+  ((void)scopy);
+  SuspendT smove(std::move(s));
+  ((void)smove);
   s = scopy;
   s = std::move(smove);
   return true;
 }
 
-int main(int, char**)
-{
-  using H = coro::coroutine_handle<>;
+int main(int, char**) {
+  using H = std::coroutine_handle<>;
   using S = SuspendT;
   H h{};
   S s{};
   S const& cs = s;
   {
     LIBCPP_STATIC_ASSERT(noexcept(s.await_ready()), "");
     static_assert(std::is_same<decltype(s.await_ready()), bool>::value, "");
     assert(s.await_ready() == false);

libcxx/test/std/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 // Test that the type is in the correct namespace
-using SuspendT = std::experimental::coroutines_v1::suspend_never;
+using SuspendT = std::suspend_never;
 
 TEST_SAFE_STATIC SuspendT safe_sn;
 constexpr SuspendT constexpr_sn;
 
 constexpr bool check_suspend_constexpr() {
   SuspendT s{};
-  const SuspendT scopy(s); ((void)scopy);
-  SuspendT smove(std::move(s)); ((void)smove);
+  const SuspendT scopy(s);
+  ((void)scopy);
+  SuspendT smove(std::move(s));
+  ((void)smove);
   s = scopy;
   s = std::move(smove);
   return true;
 }
 
-
-int main(int, char**)
-{
-  using H = coro::coroutine_handle<>;
+int main(int, char**) {
+  using H = std::coroutine_handle<>;
   using S = SuspendT;
   H h{};
   S s{};
   S const& cs = s;
   {
     LIBCPP_STATIC_ASSERT(noexcept(s.await_ready()), "");
     static_assert(std::is_same<decltype(s.await_ready()), bool>::value, "");
     assert(s.await_ready() == true);

libcxx/test/std/language.support/support.coroutines/end.to.end/await_result.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct coro_t {
   struct promise_type {
     coro_t get_return_object() {
       coroutine_handle<promise_type>{};
       return {};
     }
     suspend_never initial_suspend() { return {}; }
     suspend_never final_suspend() noexcept { return {}; }
     void return_void() {}
     static void unhandled_exception() {}
   };
 };
 
 struct B {
   ~B() {}
   bool await_ready() { return true; }
   B await_resume() { return {}; }
-  template <typename F> void await_suspend(F) {}
+  template <typename F>
+  void await_suspend(F) {}
 };
 
-
 struct A {
   ~A() {}
   bool await_ready() { return true; }
   int await_resume() { return 42; }
-  template <typename F> void await_suspend(F) {}
+  template <typename F>
+  void await_suspend(F) {}
 };
 
 int last_value = -1;
-void set_value(int x) {
-  last_value = x;
-}
+void set_value(int x) { last_value = x; }
 
 coro_t f(int n) {
   if (n == 0) {
     set_value(0);
     co_return;
   }
   int val = co_await A{};
   ((void)val);

libcxx/test/std/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // See https://llvm.org/PR33271
 // UNSUPPORTED: ubsan
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct coro_t {
   struct promise_type {
-    coro_t get_return_object() {
-      return coroutine_handle<promise_type>::from_promise(*this);
-    }
+    coro_t get_return_object() { return coroutine_handle<promise_type>::from_promise(*this); }
     suspend_never initial_suspend() { return {}; }
     suspend_never final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception() {}
   };
   coro_t(coroutine_handle<promise_type> hh) : h(hh) {}
   coroutine_handle<promise_type> h;
 };
 
 struct NoSuspend {
   bool await_ready() { return false; }
   void await_resume() {}
-  template <typename F> bool await_suspend(F) { return false; }
+  template <typename F>
+  bool await_suspend(F) {
+    return false;
+  }
 };
 
 struct DoSuspend {
   bool await_ready() { return false; }
   void await_resume() {}
-  template <typename F> bool await_suspend(F) { return true; }
+  template <typename F>
+  bool await_suspend(F) {
+    return true;
+  }
 };
 
 bool f_started, f_resumed = false;
 coro_t f() {
   f_started = true;
   co_await DoSuspend{};
   f_resumed = true;
 }

libcxx/test/std/language.support/support.coroutines/end.to.end/expected.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 #include <memory>
 
 #include "test_macros.h"
-using namespace std::experimental;
+using namespace std;
 
-struct error_tag { };
+struct error_tag {};
 
 template <typename T, typename Error = int>
 struct expected {
 
   struct Data {
-    Data() : val(), error() { }
-    Data(T v, Error e) : val(v), error(e) { }
+    Data() : val(), error() {}
+    Data(T v, Error e) : val(v), error(e) {}
     T val;
     Error error;
   };
   std::shared_ptr<Data> data;
 
   expected(T val) : data(std::make_shared<Data>(val, Error())) {}
   expected(error_tag, Error error) : data(std::make_shared<Data>(T(), error)) {}
   expected(std::shared_ptr<Data> p) : data(p) {}
 
   struct promise_type {
     std::shared_ptr<Data> data;
-    expected get_return_object() { data = std::make_shared<Data>(); return {data}; }
+    expected get_return_object() {
+      data = std::make_shared<Data>();
+      return {data};
+    }
     suspend_never initial_suspend() { return {}; }
     suspend_never final_suspend() noexcept { return {}; }
-    void return_value(T v) { data->val = v; data->error = {}; }
+    void return_value(T v) {
+      data->val = v;
+      data->error = {};
+    }
     void unhandled_exception() {}
   };
 
   bool await_ready() { return !data->error; }
   T await_resume() { return data->val; }
   void await_suspend(coroutine_handle<promise_type> h) {
     h.promise().data->error = data->error;
     h.destroy();

libcxx/test/std/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 int alive = 0;
 int ctor_called = 0;
 int dtor_called = 0;
 void reset() {
   assert(alive == 0);
   alive = 0;
   ctor_called = 0;
   dtor_called = 0;
 }
 struct Noisy {
-  Noisy() { ++alive; ++ctor_called; }
-  ~Noisy() { --alive; ++dtor_called; }
+  Noisy() {
+    ++alive;
+    ++ctor_called;
+  }
+  ~Noisy() {
+    --alive;
+    ++dtor_called;
+  }
 #if TEST_STD_VER > 14
   Noisy(Noisy const&) = delete;
 #else
   // FIXME: This test depends on copy elision taking place in C++14
   // (pre-C++17 guaranteed copy elision)
   Noisy(Noisy const&);
 #endif
 };
 
 struct Bug {
   bool await_ready() { return true; }
-  void await_suspend(std::experimental::coroutine_handle<>) {}
+  void await_suspend(std::coroutine_handle<>) {}
   Noisy await_resume() { return {}; }
 };
 struct coro2 {
   struct promise_type {
-    suspend_never initial_suspend() { return{}; }
+    suspend_never initial_suspend() { return {}; }
     suspend_never final_suspend() noexcept { return {}; }
-    coro2 get_return_object() { return{}; }
+    coro2 get_return_object() { return {}; }
     void return_void() {}
     Bug yield_value(int) { return {}; }
     void unhandled_exception() {}
   };
 };
 
 // Checks that destructors are correctly invoked for the object returned by
 // coawait.
reset();
     (void)(co_await Bug{});
     assert(ctor_called == 1);
     assert(dtor_called == 1);
     assert(alive == 0);
   }
   assert(ctor_called == 1);
   assert(dtor_called == 1);
   assert(alive == 0);
-
 }
 
 coro2 c() {
   reset();
   {
     auto x = co_yield 42;
     assert(alive == 1);
     assert(ctor_called == 1);

libcxx/test/std/language.support/support.coroutines/end.to.end/generator.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // See https://llvm.org/PR33271
 // UNSUPPORTED: ubsan
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "coroutine_types.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct minig {
   struct promise_type {
     int current_value;
     suspend_always yield_value(int value) {
       this->current_value = value;
       return {};
     }
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     minig get_return_object() { return minig{this}; };
     void return_void() {}
     void unhandled_exception() {}
   };
 
   bool move_next() {
     p.resume();
     return !p.done();
   }
   int current_value() { return p.promise().current_value; }
 
-  minig(minig &&rhs) : p(rhs.p) { rhs.p = nullptr; }
+  minig(minig&& rhs) : p(rhs.p) { rhs.p = nullptr; }
 
   ~minig() {
     if (p)
       p.destroy();
   }
 
 private:
-  explicit minig(promise_type *p)
-      : p(coroutine_handle<promise_type>::from_promise(*p)) {}
+  explicit minig(promise_type* p) : p(coroutine_handle<promise_type>::from_promise(*p)) {}
 
   coroutine_handle<promise_type> p;
 };
 
-
 minig mini_count(int n) {
   for (int i = 0; i < n; i++) {
     co_yield i;
   }
 }
 
 generator<int> count(int n) {
   for (int i = 0; i < n; ++i)
void test_count() {
   std::vector<int> got;
   for (auto x : count(5))
     got.push_back(x);
   assert(expect == got);
 }
 
 void test_range() {
   int sum = 0;
-   for (auto v: range(1, 20))
-      sum += v;
-   assert(sum == 190);
+  for (auto v : range(1, 20))
 }
 
 void test_mini_generator() {
   int sum = 0;
   auto g = mini_count(5);
   while (g.move_next()) {
-     sum += g.current_value();
   }
   assert(sum == 10);
 }
 
 int main(int, char**) {
   test_count();
   test_range();
   test_mini_generator();
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/end.to.end/go.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 bool cancel = false;
 
-struct goroutine
-{
+struct goroutine {
   static int const N = 10;
   static int count;
   static coroutine_handle<> stack[N];
 
-  static void schedule(coroutine_handle<>& rh)
-  {
+  static void schedule(coroutine_handle<>& rh) {
     assert(count < N);
     stack[count++] = rh;
     rh = nullptr;
   }
 
   ~goroutine() {}
 
   static void go(goroutine) {}
 
-  static void run_one()
-  {
+  static void run_one() {
     assert(count > 0);
     stack[--count]();
   }
 
-  struct promise_type
-  {
-    suspend_never initial_suspend() {
-      return {};
-    }
+  struct promise_type {
+    suspend_never initial_suspend() { return {}; }
     suspend_never final_suspend() noexcept { return {}; }
     void return_void() {}
-    goroutine get_return_object() {
-      return{};
-    }
+    goroutine get_return_object() { return {}; }
     void unhandled_exception() {}
   };
 };
 int goroutine::count;
 coroutine_handle<> goroutine::stack[N];
 
 coroutine_handle<goroutine::promise_type> workaround;
 
 class channel;
 
 struct push_awaiter {
   channel* ch;
-  bool await_ready() {return false; }
+  bool await_ready() { return false; }
   void await_suspend(coroutine_handle<> rh);
   void await_resume() {}
 };
 
 struct pull_awaiter {
-  channel * ch;
+  channel* ch;
 
   bool await_ready();
   void await_suspend(coroutine_handle<> rh);
   int await_resume();
 };
 
-class channel
-{
+class channel {
   using T = int;
 
   friend struct push_awaiter;
   friend struct pull_awaiter;
 
   T const* pvalue = nullptr;
   coroutine_handle<> reader = nullptr;
   coroutine_handle<> writer = nullptr;
+
 public:
-  push_awaiter push(T const& value)
-  {
+  push_awaiter push(T const& value) {
     assert(pvalue == nullptr);
     assert(!writer);
     pvalue = &value;
 
-    return { this };
+    return {this};
   }
 
-  pull_awaiter pull()
-  {
+  pull_awaiter pull() {
     assert(!reader);
 
-    return { this };
+    return {this};
   }
 
-  void sync_push(T const& value)
-  {
+  void sync_push(T const& value) {
     assert(!pvalue);
     pvalue = &value;
     assert(reader);
     reader();
     assert(!pvalue);
     reader = nullptr;
   }
 
-  auto sync_pull()
-  {
-    while (!pvalue) goroutine::run_one();
+  auto sync_pull() {
+    while (!pvalue)
+      goroutine::run_one();
     auto result = *pvalue;
     pvalue = nullptr;
-    if (writer)
-    {
+    if (writer) {
       auto wr = writer;
       writer = nullptr;
       wr();
     }
     return result;
   }
 };
 
-void push_awaiter::await_suspend(coroutine_handle<> rh)
-{
+void push_awaiter::await_suspend(coroutine_handle<> rh) {
   ch->writer = rh;
-  if (ch->reader) goroutine::schedule(ch->reader);
+  if (ch->reader)
+    goroutine::schedule(ch->reader);
 }
 
-
-bool pull_awaiter::await_ready() {
-  return !!ch->writer;
-}
-void pull_awaiter::await_suspend(coroutine_handle<> rh) {
-  ch->reader = rh;
-}
+bool pull_awaiter::await_ready() { return !!ch->writer; }
+void pull_awaiter::await_suspend(coroutine_handle<> rh) { ch->reader = rh; }
 int pull_awaiter::await_resume() {
   auto result = *ch->pvalue;
   ch->pvalue = nullptr;
   if (ch->writer) {
     //goroutine::schedule(ch->writer);
     auto wr = ch->writer;
     ch->writer = nullptr;
     wr();
   }
   return result;
 }
 
-goroutine pusher(channel& left, channel& right)
-{
+goroutine pusher(channel& left, channel& right) {
   for (;;) {
     auto val = co_await left.pull();
     co_await right.push(val + 1);
   }
 }
 
 const int N = 100;
 channel* c = new channel[N + 1];

libcxx/test/std/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 // This file tests, multishot, movable std::function like thing using coroutine
 // for compile-time type erasure and unerasure.
-template <typename R> struct func {
-  struct Input {R a, b;};
+template <typename R>
+struct func {
+  struct Input {
+    R a, b;
+  };
 
   struct promise_type {
     Input* I;
     R result;
     func get_return_object() { return {this}; }
     suspend_always initial_suspend() { return {}; }
     suspend_never final_suspend() noexcept { return {}; }
     void return_void() {}
     template <typename F>
     suspend_always yield_value(F&& f) {
       result = f(I->a, I->b);
       return {};
     }
     void unhandled_exception() {}
   };
 
   R operator()(Input I) {
     h.promise().I = &I;
     h.resume();
     R result = h.promise().result;
     return result;
   };
 
   func() {}
-  func(func &&rhs) : h(rhs.h) { rhs.h = nullptr; }
-  func(func const &) = delete;
+  func(func&& rhs) : h(rhs.h) { rhs.h = nullptr; }
+  func(func const&) = delete;
 
-  func &operator=(func &&rhs) {
+  func& operator=(func&& rhs) {
     if (this != &rhs) {
       if (h)
         h.destroy();
       h = rhs.h;
       rhs.h = nullptr;
     }
     return *this;
   }
 
-  template <typename F> static func Create(F f) {
+  template <typename F>
+  static func Create(F f) {
     for (;;) {
       co_yield f;
     }
   }
 
-  template <typename F> func(F f) : func(Create(f)) {}
+  template <typename F>
+  func(F f) : func(Create(f)) {}
 
   ~func() {
     if (h)
       h.destroy();
   }
 
 private:
-  func(promise_type *promise)
-      : h(coroutine_handle<promise_type>::from_promise(*promise)) {}
+  func(promise_type* promise) : h(coroutine_handle<promise_type>::from_promise(*promise)) {}
   coroutine_handle<promise_type> h;
 };
 
 int Do(int acc, int n, func<int> f) {
   for (int i = 0; i < n; ++i)
     acc = f({acc, i});
   return acc;
 }
 
 int main(int, char**) {
-  int result = Do(1, 10, [](int a, int b) {return a + b;});
+  int result = Do(1, 10, [](int a, int b) { return a + b; });
   assert(result == 46);
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 // This file tests, one shot, movable std::function like thing using coroutine
 // for compile-time type erasure and unerasure.
 
-template <typename R> struct func {
+template <typename R>
+struct func {
   struct promise_type {
     R result;
     func get_return_object() { return {this}; }
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_value(R v) { result = v; }
     void unhandled_exception() {}
   };
 
   R operator()() {
     h.resume();
     R result = h.promise().result;
     h.destroy();
     h = nullptr;
     return result;
   };
 
   func() {}
-  func(func &&rhs) : h(rhs.h) { rhs.h = nullptr; }
-  func(func const &) = delete;
+  func(func&& rhs) : h(rhs.h) { rhs.h = nullptr; }
+  func(func const&) = delete;
 
-  func &operator=(func &&rhs) {
+  func& operator=(func&& rhs) {
     if (this != &rhs) {
       if (h)
         h.destroy();
       h = rhs.h;
       rhs.h = nullptr;
     }
     return *this;
   }
 
-  template <typename F> static func Create(F f) { co_return f(); }
+  template <typename F>
+  static func Create(F f) {
+    co_return f();
+  }
 
-  template <typename F> func(F f) : func(Create(f)) {}
+  template <typename F>
+  func(F f) : func(Create(f)) {}
 
   ~func() {
     if (h)
       h.destroy();
   }
 
 private:
-  func(promise_type *promise)
-      : h(coroutine_handle<promise_type>::from_promise(*promise)) {}
+  func(promise_type* promise) : h(coroutine_handle<promise_type>::from_promise(*promise)) {}
   coroutine_handle<promise_type> h;
 };
 
 std::vector<int> yielded_values = {};
-int yield(int x) { yielded_values.push_back(x); return x + 1; }
-float fyield(int x) { yielded_values.push_back(x); return static_cast<float>(x + 2); }
+int yield(int x) {
+  yielded_values.push_back(x);
+  return x + 1;
+}
+float fyield(int x) {
+  yielded_values.push_back(x);
+  return static_cast<float>(x + 2);
+}
 
 void Do1(func<int> f) { yield(f()); }
 void Do2(func<double> f) { yield(static_cast<int>(f())); }
 
 int main(int, char**) {
   Do1([] { return yield(43); });
   assert((yielded_values == std::vector<int>{43, 44}));
 
   yielded_values = {};
   Do2([] { return fyield(44); });
   assert((yielded_values == std::vector<int>{44, 46}));
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/includes.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
-// <experimental/coroutine>
+// <coroutine>
 
-// Test that <experimental/coroutine> includes <new>
+// Test that <coroutine> includes <new>
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 int main(int, char**) {
   // std::nothrow is not implicitly defined by the compiler when the include is
   // missing, unlike other parts of <new>. Therefore we use std::nothrow to
   // test for #include <new>
 
   (void)std::nothrow;
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/support.limits.general/coroutine.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
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+//
+// clang-format off
+
+// <coroutine>
+
+// Test the feature test macros defined by <coroutine>
+
+/*  Constant               Value
+    __cpp_lib_coroutine    201902L [C++20]
+*/
+
+#include <coroutine>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_coroutine
+#   error "__cpp_lib_coroutine should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_coroutine
+#   error "__cpp_lib_coroutine should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_coroutine
+#   error "__cpp_lib_coroutine should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 20
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_coroutine
+#     error "__cpp_lib_coroutine should be defined in c++20"
+#   endif
+#   if __cpp_lib_coroutine != 201902L
+#     error "__cpp_lib_coroutine should have the value 201902L in c++20"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_coroutine
+#     error "__cpp_lib_coroutine should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#elif TEST_STD_VER > 20
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_coroutine
+#     error "__cpp_lib_coroutine should be defined in c++2b"
+#   endif
+#   if __cpp_lib_coroutine != 201902L
+#     error "__cpp_lib_coroutine should have the value 201902L in c++2b"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_coroutine
+#     error "__cpp_lib_coroutine should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 20
+
+int main(int, char**) { return 0; }

libcxx/test/support/coroutine_types.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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 SUPPORT_COROUTINE_TYPES_H
 #define SUPPORT_COROUTINE_TYPES_H
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 template <typename Ty> struct generator {
   struct promise_type {
     Ty current_value;
-    std::experimental::suspend_always yield_value(Ty value) {
+    std::suspend_always yield_value(Ty value) {
       this->current_value = value;
       return {};
     }
-    std::experimental::suspend_always initial_suspend() { return {}; }
-    std::experimental::suspend_always final_suspend() noexcept { return {}; }
+    std::suspend_always initial_suspend() { return {}; }
+    std::suspend_always final_suspend() noexcept { return {}; }
     generator get_return_object() { return generator{this}; };
     void return_void() {}
     void unhandled_exception() {}
   };
 
   struct iterator {
-    std::experimental::coroutine_handle<promise_type> _Coro;
+    std::coroutine_handle<promise_type> _Coro;
     bool _Done;
 
-    iterator(std::experimental::coroutine_handle<promise_type> Coro, bool Done)
-        : _Coro(Coro), _Done(Done) {}
+    iterator(std::coroutine_handle<promise_type> Coro, bool Done) : _Coro(Coro), _Done(Done) {}
 
     iterator &operator++() {
       _Coro.resume();
       _Done = _Coro.done();
       return *this;
     }
 
     bool operator==(iterator const &_Right) const {
template <typename Ty> struct generator {
   generator(generator &&rhs) : p(rhs.p) { rhs.p = nullptr; }
 
   ~generator() {
     if (p)
       p.destroy();
   }
 
 private:
-  explicit generator(promise_type *p)
-      : p(std::experimental::coroutine_handle<promise_type>::from_promise(*p)) {}
+  explicit generator(promise_type* p) : p(std::coroutine_handle<promise_type>::from_promise(*p)) {}
 
-  std::experimental::coroutine_handle<promise_type> p;
+  std::coroutine_handle<promise_type> p;
 };
 
 #endif // SUPPORT_COROUTINE_TYPES_H

libcxx/utils/generate_header_tests.py

header_markup = {
     "locale": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
     "ostream": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
     "ranges": ["ifndef _LIBCPP_HAS_NO_INCOMPLETE_RANGES"],
     "regex": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
     "sstream": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
     "streambuf": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
     "strstream": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
 
-    "experimental/coroutine": ["if defined(__cpp_coroutines)"],
+    "coroutine": ["if defined(__cpp_coroutines)"],
     "experimental/regex": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
 }
 
 allowed_extensions = ['', '.h']
 indent_width = 4
 
 
 begin_pattern = """\

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

sources = [
       "cfenv",
       "cfloat",
       "charconv",
       "chrono",
       "cinttypes",
       "ciso646",
       "climits",
       "clocale",
+      "coroutine",
       "cmath",
       "codecvt",
       "compare",
       "complex",
       "complex.h",
       "concepts",
       "condition_variable",
       "csetjmp",
sources = [
       "cwctype",
       "deque",
       "errno.h",
       "exception",
       "execution",
       "experimental/__config",
       "experimental/__memory",
       "experimental/algorithm",
-      "experimental/coroutine",
       "experimental/deque",
       "experimental/filesystem",
       "experimental/forward_list",
       "experimental/functional",
       "experimental/iterator",
       "experimental/list",
       "experimental/map",
       "experimental/memory_resource",