[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 ↗

(On Diff #368816)

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 ↗

(On Diff #368816)

Remove experimental/

86 ↗

(On Diff #368816)

(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 ↗

(On Diff #368816)

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 ↗

(On Diff #368816)

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

114 ↗

(On Diff #368816)

void destroy() const

127 ↗

(On Diff #368816)

This should be marked constexpr.

133–135 ↗

(On Diff #368816)

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 ↗

(On Diff #368816)

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 ↗

(On Diff #368816)

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

155–160 ↗

(On Diff #368816)

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 ↗

(On Diff #368816)

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 ↗

(On Diff #368816)

Remove all of this.

[• Quuxplusone]

libcxx/include/coroutine

238 ↗

(On Diff #368816)

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

285–290 ↗

(On Diff #368816)

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 ↗

(On Diff #368816)

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

libcxx/test/libcxx/experimental/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/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp

55

Undo this whitespace change.

libcxx/test/std/experimental/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/experimental/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

9–10

a-z plz

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

362 ↗

(On Diff #368816)

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)
   # Our visibility annotations are not quite right for non-Clang compilers,
   # 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>
-    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)
     target_compile_definitions(${target} PRIVATE -D_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
   endif()
 

libcxx/docs/ReleaseNotes.rst

 ------------------
 
 Improvements and New Features
 -----------------------------
 
 Deprecations and Removals
 -------------------------
 
+- The ``<experimental/coroutine>`` header has been removed in this release. The ``<coroutine>`` header
+  has been shipping since LLVM 14, so the Coroutines TS implementation is being removed per our policy
+  for removing TSes.
+
 Upcoming Deprecations and Removals
 ----------------------------------
 
 - The ``_LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED`` macro will not be honored anymore in LLVM 18.
   Please see the updated documentation about the safe libc++ mode and in particular the ``_LIBCPP_VERBOSE_ABORT``
   macro for details.
 
 API Changes
 -----------
 
 ABI Affecting Changes
 ---------------------
 
 Build System Changes
 --------------------

libcxx/include/CMakeLists.txt

set(files
   deque
   errno.h
   exception
   execution
   expected
   experimental/__config
   experimental/__memory
   experimental/algorithm
-  experimental/coroutine
   experimental/deque
   experimental/forward_list
   experimental/functional
   experimental/iterator
   experimental/list
   experimental/map
   experimental/memory_resource
   experimental/propagate_const

libcxx/include/experimental/__config

 #define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 {
 #define _LIBCPP_END_NAMESPACE_LFTS_V2  } } }
 #define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2
 
 #define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr {
 #define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS }
 #define _VSTD_LFTS_PMR _VSTD_LFTS::pmr
 
-#if !defined(__cpp_coroutines) || __cpp_coroutines < 201703L
-#define _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
-#endif
-
-#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \
-  _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 {
-
-#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES \
-  } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
-
-#define _VSTD_CORO _VSTD_EXPERIMENTAL::coroutines_v1
-
 #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \
     _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 {
 
 #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD \
     } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
     _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi {

libcxx/include/experimental/coroutine

-// -*- 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 _LIBCPP_EXPERIMENTAL_COROUTINE
-#define _LIBCPP_EXPERIMENTAL_COROUTINE
-
-/**
-    experimental/coroutine synopsis
-
-// C++next
-
-namespace std {
-namespace experimental {
-inline namespace coroutines_v1 {
-
-  // 18.11.1 coroutine traits
-template <typename R, typename... ArgTypes>
-class coroutine_traits;
-// 18.11.2 coroutine handle
-template <typename Promise = void>
-class coroutine_handle;
-// 18.11.2.7 comparison operators:
-bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
-// 18.11.3 trivial awaitables
-struct suspend_never;
-struct suspend_always;
-// 18.11.2.8 hash support:
-template <class T> struct hash;
-template <class P> struct hash<coroutine_handle<P>>;
-
-} // namespace coroutines_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__functional/hash.h>
-#include <__functional/operations.h>
-#include <cstddef>
-#include <experimental/__config>
-#include <new>
-#include <type_traits>
-
-#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#  include <atomic>
-#  include <climits>
-#  include <cmath>
-#  include <compare>
-#  include <concepts>
-#  include <ctime>
-#  include <initializer_list>
-#  include <iosfwd>
-#  include <iterator>
-#  include <memory>
-#  include <ratio>
-#  include <stdexcept>
-#  include <tuple>
-#  include <typeinfo>
-#  include <utility>
-#  include <variant>
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
-
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
-
-template <class _Tp, class = void>
-struct __coroutine_traits_sfinae {};
-
-template <class _Tp>
-struct __coroutine_traits_sfinae<_Tp, __void_t<typename _Tp::promise_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 __remove_cv_t<_Promise> _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_SINCE_CXX20 void operator()() const _NOEXCEPT {}
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 void resume() const _NOEXCEPT {}
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 void destroy() const _NOEXCEPT {}
-
-private:
-  _LIBCPP_INLINE_VISIBILITY
-  friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT;
-
-  _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT {
-    this->__handle_ = __builtin_coro_noop();
-  }
-};
-
-using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
-
-inline _LIBCPP_INLINE_VISIBILITY
-noop_coroutine_handle noop_coroutine() _NOEXCEPT {
-  return noop_coroutine_handle();
-}
-#endif // __has_builtin(__builtin_coro_noop)
-
-struct suspend_never {
-  _LIBCPP_INLINE_VISIBILITY
-  bool await_ready() const _NOEXCEPT { return true; }
-  _LIBCPP_INLINE_VISIBILITY
-  void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
-  _LIBCPP_INLINE_VISIBILITY
-  void await_resume() const _NOEXCEPT {}
-};
-
-struct suspend_always {
-  _LIBCPP_INLINE_VISIBILITY
-  bool await_ready() const _NOEXCEPT { return false; }
-  _LIBCPP_INLINE_VISIBILITY
-  void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
-  _LIBCPP_INLINE_VISIBILITY
-  void await_resume() const _NOEXCEPT {}
-};
-
-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct hash<_VSTD_CORO::coroutine_handle<_Tp> > {
-    using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>;
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(__arg_type const& __v) const _NOEXCEPT
-    {return hash<void*>()(__v.address());}
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-
-#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */

libcxx/include/module.modulemap.in

module __concepts {
       module totally_ordered            { private header "__concepts/totally_ordered.h" }
     }
   }
   module condition_variable {
     header "condition_variable"
     export *
   }
   module coroutine {
-    requires coroutines
     header "coroutine"
     export compare
     export *
 
     module __coroutine {
       module coroutine_handle           { private header "__coroutine/coroutine_handle.h" }
       module coroutine_traits           { private header "__coroutine/coroutine_traits.h" }
       module noop_coroutine_handle      { private header "__coroutine/noop_coroutine_handle.h" }

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

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.sh.cpp

 
 // RUN: %{build} -DTEST_122
 #if defined(TEST_122) && __cplusplus >= 201103L
 #   include <experimental/algorithm>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_123
-#if defined(TEST_123) && __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
+#if defined(TEST_123) && __cplusplus >= 201103L
+#   include <experimental/deque>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_124
 #if defined(TEST_124) && __cplusplus >= 201103L
-#   include <experimental/deque>
+#   include <experimental/forward_list>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_125
 #if defined(TEST_125) && __cplusplus >= 201103L
-#   include <experimental/forward_list>
+#   include <experimental/functional>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_126
 #if defined(TEST_126) && __cplusplus >= 201103L
-#   include <experimental/functional>
+#   include <experimental/iterator>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_127
 #if defined(TEST_127) && __cplusplus >= 201103L
-#   include <experimental/iterator>
+#   include <experimental/list>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_128
 #if defined(TEST_128) && __cplusplus >= 201103L
-#   include <experimental/list>
+#   include <experimental/map>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_129
 #if defined(TEST_129) && __cplusplus >= 201103L
-#   include <experimental/map>
+#   include <experimental/memory_resource>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_130
 #if defined(TEST_130) && __cplusplus >= 201103L
-#   include <experimental/memory_resource>
+#   include <experimental/propagate_const>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_131
-#if defined(TEST_131) && __cplusplus >= 201103L
-#   include <experimental/propagate_const>
+#if defined(TEST_131) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
+#   include <experimental/regex>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_132
-#if defined(TEST_132) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
-#   include <experimental/regex>
+#if defined(TEST_132) && __cplusplus >= 201103L
+#   include <experimental/set>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_133
 #if defined(TEST_133) && __cplusplus >= 201103L
-#   include <experimental/set>
+#   include <experimental/simd>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_134
 #if defined(TEST_134) && __cplusplus >= 201103L
-#   include <experimental/simd>
+#   include <experimental/string>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_135
 #if defined(TEST_135) && __cplusplus >= 201103L
-#   include <experimental/string>
+#   include <experimental/type_traits>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_136
 #if defined(TEST_136) && __cplusplus >= 201103L
-#   include <experimental/type_traits>
+#   include <experimental/unordered_map>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_137
 #if defined(TEST_137) && __cplusplus >= 201103L
-#   include <experimental/unordered_map>
+#   include <experimental/unordered_set>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_138
 #if defined(TEST_138) && __cplusplus >= 201103L
-#   include <experimental/unordered_set>
+#   include <experimental/utility>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_139
 #if defined(TEST_139) && __cplusplus >= 201103L
-#   include <experimental/utility>
+#   include <experimental/vector>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_140
-#if defined(TEST_140) && __cplusplus >= 201103L
-#   include <experimental/vector>
+#if defined(TEST_140)
+#   include <ext/hash_map>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_141
 #if defined(TEST_141)
-#   include <ext/hash_map>
-    using HandlerType = decltype(std::__libcpp_verbose_abort);
-#endif
-
-// RUN: %{build} -DTEST_142
-#if defined(TEST_142)
 #   include <ext/hash_set>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // GENERATED-MARKER

libcxx/test/libcxx/clang_tidy.sh.cpp

 #   include <wchar.h>
 #endif
 #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
 #   include <wctype.h>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/algorithm>
 #endif
-#if __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
-#endif
 #if __cplusplus >= 201103L
 #   include <experimental/deque>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/forward_list>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/functional>

libcxx/test/libcxx/double_include.sh.cpp

 #   include <wchar.h>
 #endif
 #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
 #   include <wctype.h>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/algorithm>
 #endif
-#if __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
-#endif
 #if __cplusplus >= 201103L
 #   include <experimental/deque>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/forward_list>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/functional>

libcxx/test/libcxx/experimental/language.support/support.coroutines/dialect_support.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
-//
-//===----------------------------------------------------------------------===//
-
-// REQUIRES: fcoroutines-ts
-// ADDITIONAL_COMPILE_FLAGS: -fcoroutines-ts -Wno-coroutine
-
-// A simple "breathing" test that checks that <experimental/coroutine>
-// can be parsed and used in all dialects, including C++03 in order to match
-// Clang's behavior.
-
-#include <experimental/coroutine>
-
-#include "test_macros.h"
-
-namespace coro = std::experimental::coroutines_v1;
-
-coro::suspend_always sa;
-coro::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; }
-    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;
-};
-
-MyFuture test_coro() {
-  co_await sn;
-  co_yield 42;
-  co_return;
-}
-
-int main(int, char**)
-{
-  MyFuture f = test_coro();
-  while (!f.p.done())
-    f.p.resume();
-  f.p.destroy();
-
-  return 0;
-}

libcxx/test/libcxx/experimental/language.support/support.coroutines/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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-// REQUIRES: fcoroutines-ts
-// ADDITIONAL_COMPILE_FLAGS: -fcoroutines-ts
-
-#include <experimental/coroutine>
-
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION must be defined
-#endif
-
-int main(int, char**)
-{
-
-  return 0;
-}

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

 #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
 #   include <wctype.h>
 TEST_MACROS();
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/algorithm>
 TEST_MACROS();
 #endif
-#if __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
-TEST_MACROS();
-#endif
 #if __cplusplus >= 201103L
 #   include <experimental/deque>
 TEST_MACROS();
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/forward_list>
 TEST_MACROS();
 #endif

libcxx/test/libcxx/modules_include.sh.cpp

 #if defined(TEST_121) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
 #include <wctype.h>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_122
 #if defined(TEST_122) && __cplusplus >= 201103L
 #include <experimental/algorithm>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_123
-#if defined(TEST_123) && __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#include <experimental/coroutine>
+#if defined(TEST_123) && __cplusplus >= 201103L
+#include <experimental/deque>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_124
 #if defined(TEST_124) && __cplusplus >= 201103L
-#include <experimental/deque>
+#include <experimental/forward_list>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_125
 #if defined(TEST_125) && __cplusplus >= 201103L
-#include <experimental/forward_list>
+#include <experimental/functional>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_126
 #if defined(TEST_126) && __cplusplus >= 201103L
-#include <experimental/functional>
+#include <experimental/iterator>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_127
 #if defined(TEST_127) && __cplusplus >= 201103L
-#include <experimental/iterator>
+#include <experimental/list>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_128
 #if defined(TEST_128) && __cplusplus >= 201103L
-#include <experimental/list>
+#include <experimental/map>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_129
 #if defined(TEST_129) && __cplusplus >= 201103L
-#include <experimental/map>
+#include <experimental/memory_resource>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_130
 #if defined(TEST_130) && __cplusplus >= 201103L
-#include <experimental/memory_resource>
+#include <experimental/propagate_const>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_131
-#if defined(TEST_131) && __cplusplus >= 201103L
-#include <experimental/propagate_const>
+#if defined(TEST_131) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
+#include <experimental/regex>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_132
-#if defined(TEST_132) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
-#include <experimental/regex>
+#if defined(TEST_132) && __cplusplus >= 201103L
+#include <experimental/set>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_133
 #if defined(TEST_133) && __cplusplus >= 201103L
-#include <experimental/set>
+#include <experimental/simd>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_134
 #if defined(TEST_134) && __cplusplus >= 201103L
-#include <experimental/simd>
+#include <experimental/string>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_135
 #if defined(TEST_135) && __cplusplus >= 201103L
-#include <experimental/string>
+#include <experimental/type_traits>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_136
 #if defined(TEST_136) && __cplusplus >= 201103L
-#include <experimental/type_traits>
+#include <experimental/unordered_map>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_137
 #if defined(TEST_137) && __cplusplus >= 201103L
-#include <experimental/unordered_map>
+#include <experimental/unordered_set>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_138
 #if defined(TEST_138) && __cplusplus >= 201103L
-#include <experimental/unordered_set>
+#include <experimental/utility>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_139
 #if defined(TEST_139) && __cplusplus >= 201103L
-#include <experimental/utility>
+#include <experimental/vector>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_140
-#if defined(TEST_140) && __cplusplus >= 201103L
-#include <experimental/vector>
+#if defined(TEST_140)
+#include <ext/hash_map>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_141
 #if defined(TEST_141)
-#include <ext/hash_map>
-#endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_142
-#if defined(TEST_142)
 #include <ext/hash_set>
 #endif
 // GENERATED-MARKER

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

 #   include <wchar.h>
 #endif
 #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
 #   include <wctype.h>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/algorithm>
 #endif
-#if __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
-#endif
 #if __cplusplus >= 201103L
 #   include <experimental/deque>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/forward_list>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/functional>

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

 #   include <wchar.h>
 #endif
 #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
 #   include <wctype.h>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/algorithm>
 #endif
-#if __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
-#endif
 #if __cplusplus >= 201103L
 #   include <experimental/deque>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/forward_list>
 #endif
 #if __cplusplus >= 201103L
 #   include <experimental/functional>

libcxx/test/libcxx/transitive_includes.sh.cpp

 // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_119 2> %t/header.version
 #if defined(TEST_119)
 #include <version>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_122 2> %t/header.experimental_algorithm
 #if defined(TEST_122)
 #include <experimental/algorithm>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_123 2> %t/header.experimental_coroutine
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_123 2> %t/header.experimental_deque
 #if defined(TEST_123)
-#include <experimental/coroutine>
-#endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_124 2> %t/header.experimental_deque
-#if defined(TEST_124)
 #include <experimental/deque>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_125 2> %t/header.experimental_forward_list
-#if defined(TEST_125)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_124 2> %t/header.experimental_forward_list
+#if defined(TEST_124)
 #include <experimental/forward_list>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_126 2> %t/header.experimental_functional
-#if defined(TEST_126)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_125 2> %t/header.experimental_functional
+#if defined(TEST_125)
 #include <experimental/functional>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_127 2> %t/header.experimental_iterator
-#if defined(TEST_127)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_126 2> %t/header.experimental_iterator
+#if defined(TEST_126)
 #include <experimental/iterator>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_128 2> %t/header.experimental_list
-#if defined(TEST_128)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_127 2> %t/header.experimental_list
+#if defined(TEST_127)
 #include <experimental/list>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_129 2> %t/header.experimental_map
-#if defined(TEST_129)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_128 2> %t/header.experimental_map
+#if defined(TEST_128)
 #include <experimental/map>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_130 2> %t/header.experimental_memory_resource
-#if defined(TEST_130)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_129 2> %t/header.experimental_memory_resource
+#if defined(TEST_129)
 #include <experimental/memory_resource>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_131 2> %t/header.experimental_propagate_const
-#if defined(TEST_131)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_130 2> %t/header.experimental_propagate_const
+#if defined(TEST_130)
 #include <experimental/propagate_const>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_132 2> %t/header.experimental_regex
-#if defined(TEST_132)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_131 2> %t/header.experimental_regex
+#if defined(TEST_131)
 #include <experimental/regex>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_133 2> %t/header.experimental_set
-#if defined(TEST_133)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_132 2> %t/header.experimental_set
+#if defined(TEST_132)
 #include <experimental/set>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_134 2> %t/header.experimental_simd
-#if defined(TEST_134)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_133 2> %t/header.experimental_simd
+#if defined(TEST_133)
 #include <experimental/simd>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_135 2> %t/header.experimental_string
-#if defined(TEST_135)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_134 2> %t/header.experimental_string
+#if defined(TEST_134)
 #include <experimental/string>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_136 2> %t/header.experimental_type_traits
-#if defined(TEST_136)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_135 2> %t/header.experimental_type_traits
+#if defined(TEST_135)
 #include <experimental/type_traits>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_137 2> %t/header.experimental_unordered_map
-#if defined(TEST_137)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_136 2> %t/header.experimental_unordered_map
+#if defined(TEST_136)
 #include <experimental/unordered_map>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_138 2> %t/header.experimental_unordered_set
-#if defined(TEST_138)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_137 2> %t/header.experimental_unordered_set
+#if defined(TEST_137)
 #include <experimental/unordered_set>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_139 2> %t/header.experimental_utility
-#if defined(TEST_139)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_138 2> %t/header.experimental_utility
+#if defined(TEST_138)
 #include <experimental/utility>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_140 2> %t/header.experimental_vector
-#if defined(TEST_140)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_139 2> %t/header.experimental_vector
+#if defined(TEST_139)
 #include <experimental/vector>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_141 2> %t/header.ext_hash_map
-#if defined(TEST_141)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_140 2> %t/header.ext_hash_map
+#if defined(TEST_140)
 #include <ext/hash_map>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_142 2> %t/header.ext_hash_set
-#if defined(TEST_142)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_141 2> %t/header.ext_hash_set
+#if defined(TEST_141)
 #include <ext/hash_set>
 #endif
 // RUN: %{python} %S/transitive_includes_to_csv.py %t > %t/transitive_includes.csv
 // RUN: diff -w %S/transitive_includes/%{cxx_std}.csv %t/transitive_includes.csv
 // GENERATED-MARKER

libcxx/test/libcxx/transitive_includes/cxx03.csv

 expected cstdlib
 expected exception
 expected initializer_list
 expected new
 expected version
 experimental/algorithm algorithm
 experimental/algorithm cstddef
 experimental/algorithm type_traits
-experimental/coroutine atomic
-experimental/coroutine climits
-experimental/coroutine cmath
-experimental/coroutine compare
-experimental/coroutine concepts
-experimental/coroutine cstddef
-experimental/coroutine cstdint
-experimental/coroutine cstring
-experimental/coroutine ctime
-experimental/coroutine initializer_list
-experimental/coroutine iosfwd
-experimental/coroutine iterator
-experimental/coroutine limits
-experimental/coroutine memory
-experimental/coroutine new
-experimental/coroutine ratio
-experimental/coroutine stdexcept
-experimental/coroutine tuple
-experimental/coroutine type_traits
-experimental/coroutine typeinfo
-experimental/coroutine utility
-experimental/coroutine variant
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/functional array
 experimental/functional cstddef
 experimental/functional functional
 experimental/functional type_traits

libcxx/test/libcxx/transitive_includes/cxx11.csv

 expected cstdlib
 expected exception
 expected initializer_list
 expected new
 expected version
 experimental/algorithm algorithm
 experimental/algorithm cstddef
 experimental/algorithm type_traits
-experimental/coroutine atomic
-experimental/coroutine climits
-experimental/coroutine cmath
-experimental/coroutine compare
-experimental/coroutine concepts
-experimental/coroutine cstddef
-experimental/coroutine cstdint
-experimental/coroutine cstring
-experimental/coroutine ctime
-experimental/coroutine initializer_list
-experimental/coroutine iosfwd
-experimental/coroutine iterator
-experimental/coroutine limits
-experimental/coroutine memory
-experimental/coroutine new
-experimental/coroutine ratio
-experimental/coroutine stdexcept
-experimental/coroutine tuple
-experimental/coroutine type_traits
-experimental/coroutine typeinfo
-experimental/coroutine utility
-experimental/coroutine variant
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/functional array
 experimental/functional cstddef
 experimental/functional functional
 experimental/functional type_traits

libcxx/test/libcxx/transitive_includes/cxx14.csv

 expected cstdlib
 expected exception
 expected initializer_list
 expected new
 expected version
 experimental/algorithm algorithm
 experimental/algorithm cstddef
 experimental/algorithm type_traits
-experimental/coroutine atomic
-experimental/coroutine climits
-experimental/coroutine cmath
-experimental/coroutine compare
-experimental/coroutine concepts
-experimental/coroutine cstddef
-experimental/coroutine cstdint
-experimental/coroutine cstring
-experimental/coroutine ctime
-experimental/coroutine initializer_list
-experimental/coroutine iosfwd
-experimental/coroutine iterator
-experimental/coroutine limits
-experimental/coroutine memory
-experimental/coroutine new
-experimental/coroutine ratio
-experimental/coroutine stdexcept
-experimental/coroutine tuple
-experimental/coroutine type_traits
-experimental/coroutine typeinfo
-experimental/coroutine utility
-experimental/coroutine variant
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/functional array
 experimental/functional cstddef
 experimental/functional functional
 experimental/functional type_traits

libcxx/test/libcxx/transitive_includes/cxx17.csv

 expected cstdlib
 expected exception
 expected initializer_list
 expected new
 expected version
 experimental/algorithm algorithm
 experimental/algorithm cstddef
 experimental/algorithm type_traits
-experimental/coroutine atomic
-experimental/coroutine climits
-experimental/coroutine cmath
-experimental/coroutine compare
-experimental/coroutine concepts
-experimental/coroutine cstddef
-experimental/coroutine cstdint
-experimental/coroutine cstring
-experimental/coroutine ctime
-experimental/coroutine initializer_list
-experimental/coroutine iosfwd
-experimental/coroutine iterator
-experimental/coroutine limits
-experimental/coroutine memory
-experimental/coroutine new
-experimental/coroutine ratio
-experimental/coroutine stdexcept
-experimental/coroutine tuple
-experimental/coroutine type_traits
-experimental/coroutine typeinfo
-experimental/coroutine utility
-experimental/coroutine variant
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/functional array
 experimental/functional cstddef
 experimental/functional functional
 experimental/functional type_traits

libcxx/test/libcxx/transitive_includes/cxx20.csv

 expected cstdlib
 expected exception
 expected initializer_list
 expected new
 expected version
 experimental/algorithm algorithm
 experimental/algorithm cstddef
 experimental/algorithm type_traits
-experimental/coroutine atomic
-experimental/coroutine climits
-experimental/coroutine cmath
-experimental/coroutine compare
-experimental/coroutine concepts
-experimental/coroutine cstddef
-experimental/coroutine cstdint
-experimental/coroutine cstring
-experimental/coroutine ctime
-experimental/coroutine initializer_list
-experimental/coroutine iosfwd
-experimental/coroutine iterator
-experimental/coroutine limits
-experimental/coroutine memory
-experimental/coroutine new
-experimental/coroutine ratio
-experimental/coroutine stdexcept
-experimental/coroutine tuple
-experimental/coroutine type_traits
-experimental/coroutine typeinfo
-experimental/coroutine utility
-experimental/coroutine variant
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/functional array
 experimental/functional cstddef
 experimental/functional functional
 experimental/functional type_traits

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 expected cstdlib
 expected exception
 expected initializer_list
 expected new
 expected version
 experimental/algorithm algorithm
 experimental/algorithm cstddef
 experimental/algorithm type_traits
-experimental/coroutine cstddef
-experimental/coroutine cstdint
-experimental/coroutine cstring
-experimental/coroutine limits
-experimental/coroutine new
-experimental/coroutine type_traits
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
 experimental/functional array
 experimental/functional cstddef
 experimental/functional functional
 experimental/functional type_traits

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// namespace std {
-//  template <class P> struct hash<experimental::coroutine_handle<P>>;
-// }
-
-#include <experimental/coroutine>
-#include <type_traits>
-#include <memory>
-#include <utility>
-#include <cstdint>
-#include <cassert>
-#include <functional>
-
-#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}
-  };
-  for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
-  }
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// constexpr explicit operator bool() const noexcept
-
-#include <experimental/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);
-    static_assert(bool(c) == false, "");
-  }
-  { // null case
-    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>>();
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/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 <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}
-  };
-  for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
-  }
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/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 <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}
-  };
-  for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
-  }
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// bool done() const
-
-#include <experimental/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) {
-  // 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>{});
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// coroutine_handle& operator=(nullptr_t) noexcept
-
-#include <experimental/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);
-    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>>();
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// constexpr coroutine_handle() noexcept
-// constexpr coroutine_handle(nullptr_t) noexcept
-
-#include <experimental/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>>();
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// constexpr void* address() const noexcept
-
-#include <experimental/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);
-    static_assert(c.address() == nullptr, "");
-  }
-  {
-    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>>();
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-// <experimental/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 <type_traits>
-#include <cassert>
-
-namespace coro = std::experimental;
-
-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}}
-    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-re@experimental/coroutine:* 1 {{{{(static_assert|static assertion)}} 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}}
-    H::from_address((int*)nullptr); // expected-note {{requested here}}
-  }
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// static coroutine_handle from_address(void*) noexcept
-
-#include <experimental/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>>();
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-// UNSUPPORTED: ubsan
-
-// <experimental/coroutine>
-// struct noop_coroutine_promise;
-// using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
-// noop_coroutine_handle noop_coroutine() noexcept;
-
-#include <experimental/coroutine>
-#include <cassert>
-#include <type_traits>
-
-#include "test_macros.h"
-
-#if TEST_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, "");
-
-// 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;
-
-  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);
-
-  return 0;
-}
-
-#else
-
-int main(int, char**) { return 0; }
-
-#endif //  TEST_HAS_BUILTIN(__builtin_coro_noop)

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise>
-// struct coroutine_handle<Promise>;
-
-// Promise& promise() const
-
-#include <experimental/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 {}; }
-    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;
-      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{};
-}
-
-template <class Promise>
-void do_test(coro::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>{});
-  do_runtime_test();
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// void destroy()
-
-#include <experimental/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>;
-  // 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>{});
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// template <class Promise = void>
-// struct coroutine_handle;
-
-// void operator()()
-// void resume()
-
-#include <experimental/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>;
-  // 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>{});
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/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;
-  };
-}}
-
-template <class Expect, class T, class ...Args>
-void check_type() {
-  using P = typename coro::coroutine_traits<T, Args...>::promise_type ;
-  static_assert(std::is_same<P, Expect>::value, "");
-};
-
-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/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/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; }
-template <class>
-constexpr bool has_promise_type(long) { return false; }
-template <class T>
-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;
-  };
-}}
-
-template <class Expect, class T, class ...Args>
-void check_type() {
-  using Traits = coro::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>
-void check_no_type() {
-  using Traits = coro::coroutine_traits<T, Args...>;
-  static_assert(!has_promise_type<Traits>(), "");
-}
-
-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/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/coroutine>
-#include <type_traits>
-#include <cassert>
-#include <utility>
-
-#include "test_macros.h"
-
-namespace coro = std::experimental;
-
-using SuspendT = std::experimental::coroutines_v1::suspend_always;
-
-constexpr bool check_suspend_constexpr() {
-  SuspendT s;
-  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<>;
-  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);
-    assert(cs.await_ready() == false);
-  }
-  {
-    LIBCPP_STATIC_ASSERT(noexcept(s.await_suspend(h)), "");
-    static_assert(std::is_same<decltype(s.await_suspend(h)), void>::value, "");
-    s.await_suspend(h);
-    cs.await_suspend(h);
-  }
-  {
-    LIBCPP_STATIC_ASSERT(noexcept(s.await_resume()), "");
-    static_assert(std::is_same<decltype(s.await_resume()), void>::value, "");
-    s.await_resume();
-    cs.await_resume();
-  }
-  {
-    static_assert(std::is_nothrow_default_constructible<S>::value, "");
-    static_assert(std::is_nothrow_copy_constructible<S>::value, "");
-    static_assert(std::is_nothrow_move_constructible<S>::value, "");
-    static_assert(std::is_nothrow_copy_assignable<S>::value, "");
-    static_assert(std::is_nothrow_move_assignable<S>::value, "");
-    static_assert(std::is_trivially_copyable<S>::value, "");
-    static_assert(check_suspend_constexpr(), "");
-  }
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/coroutine>
-#include <type_traits>
-#include <cassert>
-#include <utility>
-
-#include "test_macros.h"
-
-namespace coro = std::experimental;
-
-using SuspendT = std::experimental::coroutines_v1::suspend_never;
-
-constexpr bool check_suspend_constexpr() {
-  SuspendT s;
-  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<>;
-  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);
-    assert(cs.await_ready() == true);
-  }
-  {
-    LIBCPP_STATIC_ASSERT(noexcept(s.await_suspend(h)), "");
-    static_assert(std::is_same<decltype(s.await_suspend(h)), void>::value, "");
-    s.await_suspend(h);
-    cs.await_suspend(h);
-  }
-  {
-    LIBCPP_STATIC_ASSERT(noexcept(s.await_resume()), "");
-    static_assert(std::is_same<decltype(s.await_resume()), void>::value, "");
-    s.await_resume();
-    cs.await_resume();
-  }
-  {
-    static_assert(std::is_nothrow_default_constructible<S>::value, "");
-    static_assert(std::is_nothrow_copy_constructible<S>::value, "");
-    static_assert(std::is_nothrow_move_constructible<S>::value, "");
-    static_assert(std::is_nothrow_copy_assignable<S>::value, "");
-    static_assert(std::is_nothrow_move_assignable<S>::value, "");
-    static_assert(std::is_trivially_copyable<S>::value, "");
-    static_assert(check_suspend_constexpr(), "");
-  }
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/coroutine>
-#include <cassert>
-
-#include "test_macros.h"
-
-using namespace std::experimental;
-
-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) {}
-};
-
-
-struct A {
-  ~A() {}
-  bool await_ready() { return true; }
-  int await_resume() { return 42; }
-  template <typename F> void await_suspend(F) {}
-};
-
-int last_value = -1;
-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);
-  set_value(42);
-}
-
-coro_t g() { B val = co_await B{}; }
-
-int main(int, char**) {
-  last_value = -1;
-  f(0);
-  assert(last_value == 0);
-  f(1);
-  assert(last_value == 42);
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// See https://llvm.org/PR33271
-// UNSUPPORTED: ubsan
-
-#include <experimental/coroutine>
-#include <cassert>
-
-#include "test_macros.h"
-
-using namespace std::experimental;
-
-struct coro_t {
-  struct promise_type {
-    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; }
-};
-
-struct DoSuspend {
-  bool await_ready() { return false; }
-  void await_resume() {}
-  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;
-}
-
-bool g_started, g_resumed = false;
-coro_t g() {
-  g_started = true;
-  co_await NoSuspend{};
-  g_resumed = true;
-}
-
-int main(int, char**) {
-  assert(!f_started && !f_resumed && !g_started && !g_resumed);
-  auto fret = f();
-  assert(f_started && !f_resumed);
-  fret.h.destroy();
-  assert(f_started && !f_resumed);
-  g();
-  assert(g_started && g_resumed);
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/coroutine>
-#include <cassert>
-#include <memory>
-
-#include "test_macros.h"
-using namespace std::experimental;
-
-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) { }
-    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}; }
-    suspend_never initial_suspend() { return {}; }
-    suspend_never final_suspend() noexcept { return {}; }
-    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();
-  }
-
-  T const& value() { return data->val; }
-  Error const& error() { return data->error; }
-};
-
-expected<int> g() { return {0}; }
-expected<int> h() { return {error_tag{}, 42}; }
-
-extern "C" void print(int);
-
-bool f1_started, f1_resumed = false;
-expected<int> f1() {
-  f1_started = true;
-  (void)(co_await g());
-  f1_resumed = true;
-  co_return 100;
-}
-
-bool f2_started, f2_resumed = false;
-expected<int> f2() {
-  f2_started = true;
-  (void)(co_await h());
-  f2_resumed = true;
-  co_return 200;
-}
-
-int main(int, char**) {
-  auto c1 = f1();
-  assert(f1_started && f1_resumed);
-  assert(c1.value() == 100);
-  assert(c1.error() == 0);
-
-  auto c2 = f2();
-  assert(f2_started && !f2_resumed);
-  assert(c2.value() == 0);
-  assert(c2.error() == 42);
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/coroutine>
-#include <cassert>
-
-#include "test_macros.h"
-
-using namespace std::experimental;
-
-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; }
-#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<>) {}
-  Noisy await_resume() { return {}; }
-};
-struct coro2 {
-  struct promise_type {
-    suspend_never initial_suspend() { return{}; }
-    suspend_never final_suspend() noexcept { 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.
-coro2 a() {
-  reset();
-  {
-    auto x = co_await Bug{};
-    assert(alive == 1);
-    assert(ctor_called == 1);
-    assert(dtor_called == 0);
-    ((void)x);
-  }
-  assert(alive == 0);
-  assert(dtor_called == 1);
-}
-
-coro2 b() {
-  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);
-    assert(dtor_called == 0);
-  }
-  assert(alive == 0);
-  assert(ctor_called == 1);
-  assert(dtor_called == 1);
-}
-
-coro2 d() {
-  reset();
-  {
-    (void)(co_yield 42);
-    assert(ctor_called == 1);
-    assert(dtor_called == 1);
-    assert(alive == 0);
-  }
-  assert(alive == 0);
-  assert(ctor_called == 1);
-  assert(dtor_called == 1);
-}
-
-int main(int, char**) {
-  a();
-  b();
-  c();
-  d();
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// See https://llvm.org/PR33271
-// UNSUPPORTED: ubsan
-
-#include <experimental/coroutine>
-#include <vector>
-#include <cassert>
-
-#include "test_macros.h"
-
-
-template <typename Ty> struct generator {
-  struct promise_type {
-    Ty current_value;
-    std::experimental::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 {}; }
-    generator get_return_object() { return generator{this}; };
-    void return_void() {}
-    void unhandled_exception() {}
-  };
-
-  struct iterator {
-    std::experimental::coroutine_handle<promise_type> _Coro;
-    bool _Done;
-
-    iterator(std::experimental::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 {
-      return _Done == _Right._Done;
-    }
-
-    bool operator!=(iterator const &_Right) const { return !(*this == _Right); }
-
-    Ty const &operator*() const { return _Coro.promise().current_value; }
-
-    Ty const *operator->() const { return &(operator*()); }
-  };
-
-  iterator begin() {
-    p.resume();
-    return {p, p.done()};
-  }
-
-  iterator end() { return {p, true}; }
-
-  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)) {}
-
-  std::experimental::coroutine_handle<promise_type> p;
-};
-
-struct minig {
-  struct promise_type {
-    int current_value;
-    std::experimental::suspend_always yield_value(int value) {
-      this->current_value = value;
-      return {};
-    }
-    std::experimental::suspend_always initial_suspend() { return {}; }
-    std::experimental::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() {
-    if (p)
-      p.destroy();
-  }
-
-private:
-  explicit minig(promise_type *p)
-      : p(std::experimental::coroutine_handle<promise_type>::from_promise(*p)) {}
-
-  std::experimental::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)
-    co_yield i;
-}
-
-generator<int> range(int from, int n) {
-  for (int i = from; i < n; ++i)
-    co_yield i;
-}
-
-void test_count() {
-  const std::vector<int> expect = {0, 1, 2, 3, 4};
-  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);
-}
-
-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/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/coroutine>
-#include <cassert>
-
-#include "test_macros.h"
-
-using namespace std::experimental;
-
-bool cancel = false;
-
-struct goroutine
-{
-  static int const N = 10;
-  static int count;
-  static coroutine_handle<> stack[N];
-
-  static void schedule(coroutine_handle<>& rh)
-  {
-    assert(count < N);
-    stack[count++] = rh;
-    rh = nullptr;
-  }
-
-  ~goroutine() {}
-
-  static void go(goroutine) {}
-
-  static void run_one()
-  {
-    assert(count > 0);
-    stack[--count]();
-  }
-
-  struct promise_type
-  {
-    suspend_never initial_suspend() {
-      return {};
-    }
-    suspend_never final_suspend() noexcept { return {}; }
-    void return_void() {}
-    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; }
-  void await_suspend(coroutine_handle<> rh);
-  void await_resume() {}
-};
-
-struct pull_awaiter {
-  channel * ch;
-
-  bool await_ready();
-  void await_suspend(coroutine_handle<> rh);
-  int await_resume();
-};
-
-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)
-  {
-    assert(pvalue == nullptr);
-    assert(!writer);
-    pvalue = &value;
-
-    return { this };
-  }
-
-  pull_awaiter pull()
-  {
-    assert(!reader);
-
-    return { this };
-  }
-
-  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 result = *pvalue;
-    pvalue = nullptr;
-    if (writer)
-    {
-      auto wr = writer;
-      writer = nullptr;
-      wr();
-    }
-    return result;
-  }
-};
-
-void push_awaiter::await_suspend(coroutine_handle<> rh)
-{
-  ch->writer = rh;
-  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;
-}
-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)
-{
-  for (;;) {
-    auto val = co_await left.pull();
-    co_await right.push(val + 1);
-  }
-}
-
-const int N = 100;
-channel* c = new channel[N + 1];
-
-int main(int, char**) {
-  for (int i = 0; i < N; ++i)
-    goroutine::go(pusher(c[i], c[i + 1]));
-
-  c[0].sync_push(0);
-  int result = c[N].sync_pull();
-
-  assert(result == 100);
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-#include <experimental/coroutine>
-#include <cassert>
-
-#include "test_macros.h"
-
-using namespace std::experimental;
-
-// 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;};
-
-  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 &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) {
-    for (;;) {
-      co_yield 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)) {}
-  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;});
-  assert(result == 46);
-
-  return 0;
-}

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// XFAIL: libcpp-has-debug-mode
-
-#include <experimental/coroutine>
-#include <vector>
-#include <cassert>
-
-#include "test_macros.h"
-
-using namespace std::experimental;
-
-// This file tests, one shot, movable std::function like thing using coroutine
-// for compile-time type erasure and unerasure.
-
-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 &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> func(F f) : func(Create(f)) {}
-
-  ~func() {
-    if (h)
-      h.destroy();
-  }
-
-private:
-  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); }
-
-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/experimental/language.support/support.coroutines/includes.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <experimental/coroutine>
-
-// Test that <experimental/coroutine> includes <new>
-
-#include <experimental/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/experimental/language.support/support.coroutines/lit.local.cfg

-# If the compiler doesn't support coroutines mark all of the tests under
-# this directory as unsupported. Otherwise add the required `-fcoroutines-ts`
-# flag.
-if 'fcoroutines-ts' not in config.available_features:
-  config.unsupported = True
-else:
-  config.test_format.addCompileFlags(config, '-fcoroutines-ts')
-  config.test_format.addCompileFlags(config, '-Wno-coroutine')

libcxx/utils/generate_header_tests.py

 #!/usr/bin/env python
 
 import contextlib
 import glob
 import io
 import os
 import pathlib
 import re
 
 header_restrictions = {
     "barrier": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "future": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "latch": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "semaphore": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "shared_mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "stdatomic.h": "__cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS)",
     "thread": "!defined(_LIBCPP_HAS_NO_THREADS)",
header_restrictions = {
     "strstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
 
     "wctype.h": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
     "cwctype": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
     "cwchar": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
     "wchar.h": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
 
     "experimental/algorithm": "__cplusplus >= 201103L",
-    "experimental/coroutine": "__cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)",
     "experimental/deque": "__cplusplus >= 201103L",
     "experimental/forward_list": "__cplusplus >= 201103L",
     "experimental/functional": "__cplusplus >= 201103L",
     "experimental/iterator": "__cplusplus >= 201103L",
     "experimental/list": "__cplusplus >= 201103L",
     "experimental/map": "__cplusplus >= 201103L",
     "experimental/memory_resource": "__cplusplus >= 201103L",
     "experimental/propagate_const": "__cplusplus >= 201103L",

libcxx/utils/libcxx/test/features.py

try:
 
     if int(re.search('[0-9]+', commandOutput(cfg, ['clang-tidy --version'])).group()) >= 16:
       return 'clang-tidy'
 
   except ConfigurationRuntimeError:
     return None
 
 DEFAULT_FEATURES = [
-  Feature(name='fcoroutines-ts',
-          when=lambda cfg: hasCompileFlag(cfg, '-fcoroutines-ts') and
-                           featureTestMacros(cfg, flags='-fcoroutines-ts').get('__cpp_coroutines', 0) >= 201703,
-          actions=[AddCompileFlag('-fcoroutines-ts')]),
-
   Feature(name='thread-safety',
           when=lambda cfg: hasCompileFlag(cfg, '-Werror=thread-safety'),
           actions=[AddCompileFlag('-Werror=thread-safety')]),
 
   Feature(name='diagnose-if-support',
           when=lambda cfg: hasCompileFlag(cfg, '-Wuser-defined-warnings'),
           actions=[AddCompileFlag('-Wuser-defined-warnings')]),
 

libcxx/utils/libcxx/test/format.py

def execute(self, test, litConfig):
             else:
                 steps = [
                     "%dbg(COMPILED WITH) ! %{cxx} %s %{flags} %{compile_flags} -fsyntax-only"
                 ]
             return self._executeShTest(test, litConfig, steps)
         else:
             return lit.Test.Result(lit.Test.UNRESOLVED, "Unknown test suffix for '{}'".format(filename))
 
-    # Utility function to add compile flags in lit.local.cfg files.
-    def addCompileFlags(self, config, *flags):
-        string = ' '.join(flags)
-        config.substitutions = [(s, x + ' ' + string) if s == '%{compile_flags}' else (s, x) for (s, x) in config.substitutions]
-
     def _executeShTest(self, test, litConfig, steps):
         if test.config.unsupported:
             return lit.Test.Result(lit.Test.UNSUPPORTED, 'Test is unsupported')
 
         script = parseScript(test, steps)
         if isinstance(script, lit.Test.Result):
             return script
 
         if litConfig.noExecute:
             return lit.Test.Result(lit.Test.XFAIL if test.isExpectedToFail() else lit.Test.PASS)
         else:
             _, tmpBase = _getTempPaths(test)
             useExternalSh = False
             return lit.TestRunner._runShTest(test, litConfig, useExternalSh, script, tmpBase)