[Coroutines] [Frontend] Lookup in std namespace first

[ChuanqiXu]

Summary

Now in libcxx and clang, all the coroutine components are defined in std::experimental namespace.
And now the coroutine TS is merged into C++20. So in the working draft like N4892, we could find the coroutine components is defined in std namespace instead of std::experimental namespace.
And the coroutine support in clang seems to be relatively stable. So I think it may be suitable to move the coroutine component into the experiment namespace now.

But move the coroutine component into the std namespace may be an break change. So I planned to split this change into two patch. One in clang and other in libcxx.

This patch would make clang lookup coroutine_traits in std namespace first. For the compatibility consideration, clang would lookup in std::experimental namespace if it can't find definitions in std namespace. So the existing codes wouldn't be break after update compiler.

Test Plan: check-clang, check-libcxx

[ChuanqiXu]

• Emit warning if the compiler finds the user are using std::experimental namespace:

warning message is:

coroutine_traits defined in std::experimental namespace is deprecated. Considering update libcxx and include <coroutine> instead of <experimental/coroutine>.

[ChuanqiXu]

@rjmccall @lxfind @junparser hi, do you feel comfortable with this?

[avogelsgesang]

clang/include/clang/Basic/DiagnosticSemaKinds.td

11015

Considering update -> Consider updating

[ChuanqiXu]

Address comments.

clang/include/clang/Basic/DiagnosticSemaKinds.td

11015

Done. Thanks for suggestion!

[lxfind]

LGTM. Thanks!

[uabelho]

This patch makes several libcxx tests fail due to the new warning. See e.g.
http://lab.llvm.org:8011/#/builders/60/builds/4632

[gulfem]

We started seeing the following test failures in our Fuchsia builds after this patch:

Failed Tests (10):
  libc++ :: libcxx/experimental/language.support/support.coroutines/dialect_support.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
  libc++ :: std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp

https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8837144494402864417/+/u/clang/test/stdout

Do you have any idea what might be going wrong?

[ldionne]

Based on the commit description, I don't understand this change at all. Why do we want to tweak the name lookup just for std::coroutine? Yes, we do have an action item to finish coroutines in libc++ already, and I'd love to see a patch that does that, but I don't think that mandates changing Clang.

The rollout plan for coroutines should be:

1. Make sure we implement coroutines fully
2. Duplicate it all into namespace std
3. In two LLVM releases, remove all the coroutines stuff in std::experimental.

I'm going to revert this for now on the basis that it breaks libc++ CI. Let's have a discussion about the above if you think I'm mistaken or if I'm misunderstanding what this patch does.

[ldionne]

(woops, this closed the rev when I committed the revert)

[ChuanqiXu]

In D108696#2983021, @ldionne wrote:

Based on the commit description, I don't understand this change at all. Why do we want to tweak the name lookup just for std::coroutine? Yes, we do have an action item to finish coroutines in libc++ already, and I'd love to see a patch that does that, but I don't think that mandates changing Clang.

The rollout plan for coroutines should be:

1. Make sure we implement coroutines fully
2. Duplicate it all into namespace std
3. In two LLVM releases, remove all the coroutines stuff in std::experimental.

I'm going to revert this for now on the basis that it breaks libc++ CI. Let's have a discussion about the above if you think I'm mistaken or if I'm misunderstanding what this patch does.

Many thanks for reverting this!

Why do we want to tweak the name lookup just for std::coroutine? Yes, we do have an action item to finish coroutines in libc++ already

This is due to a practice that:

• People want to use clang but they prefer to use libstdc++ instead of libc++.
• So that they would implement a coroutine.h by coping from libc++. So that they could depend on libstdc++ still.

This is a reason that I introduce the warning in the compiler side instead of libc++. But if this warning matters, I am Ok to emit the warning in the compiler side.

Then let's talk about the plans to move coroutine components into std namespace:

In D108697, the successor of this patch, we had duplicated all the components into namespace std. (And I add an warning in std::experimental by #warning directive, I am not sure if this warning may break the CI)
Then here is the problem, we must commit this before D108697, otherwise the compiler wouldn't search coroutine components in std namespace.
The solution I got now is that I should remove the warning message in this patch. Then the compiler would still try to lookup in std::experimental namespace without warning if it can't find things in std namespace.
Do you @ldionne @Quuxplusone think this solution workable?

[ChuanqiXu]

Remove warning if the compiler found std::experimental::coroutine_traits to avoid libcxx CI problems.

---

I still think this warning is beneficial. We need to note the user who update clang only that they need to update libcxx too.
So I think we should add this warning after D108697 merged in.

[ChuanqiXu]

We should proceed after D108697 accepted.

[ChuanqiXu]

@ldionne @Quuxplusone Now the compiler wouldn't emit warning for <experimental/coroutine> any more. So I think this is good. Do you feel good with this? This is necessary to conform the implementation of coroutine since the compiler would search coroutine components in corresponding namespace (std::experimental before and both std and std::experimental after this patch).

[ldionne]

This sounds more reasonable to me, however we need to ship <coroutine> in libc++ before we enable this, or else we're going to start suggesting that users include <coroutine> when we don't have it.

clang/lib/Sema/SemaCoroutine.cpp

1668

1677

Add a warning about what?

clang/test/SemaCXX/coroutines-exp-namespace.cpp

3

[ChuanqiXu]

Address comments.

[ChuanqiXu]

In D108696#3018045, @ldionne wrote:

This sounds more reasonable to me, however we need to ship <coroutine> in libc++ before we enable this, or else we're going to start suggesting that users include <coroutine> when we don't have it.

We couldn't ship '<coroutine>' before we enable this. Otherwise the compiler couldn't find coroutine components defined in std namespace.
The patch before tries to emit warning for user who including <experimental/coroutine> but it broke the CI system of libcxx. That's the reason that the first commit get reverted.
I think the right order may be:

• Check in this.
• Then check in D109433.
• Add a warning to tell people that they should include <coroutine> instead of <experimental/coroutine>. This patch should be simple enough to check in quickly.

How do you think about this order?

[ChuanqiXu]

@ldionne @Quuxplusone gentle ping~

[ChuanqiXu]

Rebase with trunk.
Hi @Quuxplusone. This patch is necessary for D109433. This patch would search the std namespace first and search std::experimental namespace if the search in std namespace failed. The reason why it got reverted before was that this original patch would emit warning when find components in std::experimental namespace. And now it wouldn't emit any warning. Would you be happy with this? I want to check-in this to avoid extra rebase work.

[avogelsgesang]

Hi @ChuanqiXu

sorry for what might be naive questions, but just to make sure I understand the context of this patch correctly:

This patch fixes the look up of the coroutine_traits, so that clang now search both the std and the std::experimental namespace. As such, it must land before D109433 since otherwise the new std::coroutine_traits wouldn't be found by the compiler, correct?

Also, does this patch enable me to use clang-cl to build programs which use the coroutine header from Microsoft's STL? Or are there still other incompatibilities between clang and the Microsoft STL with regards to coroutines?

[ChuanqiXu]

In D108696#3069723, @avogelsgesang wrote:

Hi @ChuanqiXu

sorry for what might be naive questions, but just to make sure I understand the context of this patch correctly:

Hi, you are welcome : )

This patch fixes the look up of the coroutine_traits, so that clang now search both the std and the std::experimental namespace. As such, it must land before D109433 since otherwise the new std::coroutine_traits wouldn't be found by the compiler, correct?

Yes, correct.

Also, does this patch enable me to use clang-cl to build programs which use the coroutine header from Microsoft's STL? Or are there still other incompatibilities between clang and the Microsoft STL with regards to coroutines?

After this patch, it should be able to compile <coroutine> MS STL. Otherwise, there must be a bug in either the clang part or in the MS STL part.

[ChuanqiXu]

@Quuxplusone gentle ping~

[• Quuxplusone]

In D108696#3082866, @ChuanqiXu wrote:

@Quuxplusone gentle ping~

I think this PR is mostly above my pay grade. :)
IIUC, there is a chicken-and-egg problem between D108696 and D109433? If I understand the situation correctly (which maybe I don't), I think you should add D108696 as a "Parent Revision" of D109433, and tag both of them with both "libc++" and "clang" project tags, and then poke buildkite to re-run the CI on both of them. I would hope that D109433's test results would still be green. And then you'd land both D108696 and D109433 in very quick succession. But, I'm not going to be an approver on D108696 because it's over my head. Originally you pinged @rjmccall @lxfind @junparser ; are they still happy with D108696 and the general direction we're taking on coroutines stuff in 14.x and 15.x?

(AIUI, the intent is for libc++ 14.x to support both C++11 <experimental/coroutine> and C++20 <coroutine>, and then in libc++ 15.x to support only C++20 <coroutine>.)

clang/test/SemaCXX/coroutine_handle-addres-return-type.cpp

1

Pre-existing: in the name of this file, addres should be address

clang/test/SemaCXX/coroutines-exp-namespace.cpp

3

...and not just "could work," but "works." :)

// This file is the same as coroutines.cpp, except the components are defined in namespace std::experimental.
// The intent of this test is to make sure the std::experimental implementation still works.
// TODO: Remove this test once we drop support for <experimental/coroutine>.

Also, it occurs to me that you should probably be testing both <coroutine> and <experimental/coroutine> in all the other tests, as well; e.g. coroutine_handle-address-return-type.cpp should have a matching coroutine_handle-address-return-type-exp-namespace.cpp and so on. Otherwise, aren't you removing a lot of regression tests for <experimental/coroutine>, despite that we still claim to support <experimental/coroutine> in Clang 14.x?

In many cases, it should be possible to do something like

// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -fsyntax-only -verify %s -DINCLUDE_EXPERIMENTAL=1
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s -DINCLUDE_EXPERIMENTAL=0

#if INCLUDE_EXPERIMENTAL
#include <experimental/coroutine>
namespace coro = std::experimental;
#else
#include <coroutine>
namespace coro = std;
#endif

[...]

[ChuanqiXu]

In D108696#3083081, @Quuxplusone wrote:

In D108696#3082866, @ChuanqiXu wrote:

@Quuxplusone gentle ping~

I think this PR is mostly above my pay grade. :)

Sorry for disturbing. I would remind it.

IIUC, there is a chicken-and-egg problem between D108696 and D109433? If I understand the situation correctly (which maybe I don't), I think you should add D108696 as a "Parent Revision" of D109433, and tag both of them with both "libc++" and "clang" project tags, and then poke buildkite to re-run the CI on both of them. I would hope that D109433's test results would still be green. And then you'd land both D108696 and D109433 in very quick succession. But, I'm not going to be an approver on D108696 because it's over my head. Originally you pinged @rjmccall @lxfind @junparser ; are they still happy with D108696 and the general direction we're taking on coroutines stuff in 14.x and 15.x?

(AIUI, the intent is for libc++ 14.x to support both C++11 <experimental/coroutine> and C++20 <coroutine>, and then in libc++ 15.x to support only C++20 <coroutine>.)

Yeah, this is a Parent Revision of D109433. But I didn't tag this with 'libc++' since it didn't touch libcxx part. Do you mean it is necessary to tag it as 'libc++' even if it didn't touch libcxx?
(I would try to make D109433 green, of course)

This revision is approved originally but reverted due to the unwanted warning. I would ask them if they are happy with the current direction.

After all, thanks for looking into this : )

clang/test/SemaCXX/coroutines-exp-namespace.cpp

3

Thanks for reporting this. I would try to test both by duplicating the tests. The method to use macro may not be good due to it needs to mangled.

[ChuanqiXu]

clang/test/SemaCXX/coroutines-exp-namespace.cpp

3

(Ignore this) I just noticed that we could use the macro based method for Sema tests.

[ChuanqiXu]

Rebase and address comments. Test both std::experimental::coroutine and std::coroutine in SemaCXX. All the name of tests testing std::experimental::coroutine ends with *-exp-namespace.cpp so that we could remove them easily once we want.
@lxfind @rjmccall @junparser Do you feel good with the plan that support <experiemental/coroutine> after LLVM15? Since libcxx plans to stop supporting <experimental/coroutine> in LLVM15, I think we could make a plan to remove the support for std::experimental::coroutine in clang until LLVM16.

[lewissbaker]

So am I correct in understanding that the main issue with the chicken/egg problem for updating both the compiler to use the new stdlib facilities and updating the stdlib facilities is that we don't want to issue warnings about using <experimental/coroutine> and telling users to use <coroutine> instead if there is no <coroutine> header.

I wonder if a suitable transition approach here might be to have the compiler do:

• try lookup of std::coroutine_handle/coroutine_traits; if found try to instantiate the expression (e.g. await-suspend) using the std:: type
• if not found then try lookup of std::experimental::coroutine_handle/coroutine_traits; and if found try to instantiate the expression using the std::experimental:: type; and if successful, then;
  • if std:: type was found but instantiating the expression failed, then issue a warning about using deprecated std::experimental:: types
  • otherwise if std:: type was not found, try to find <coroutine> header and if present then issue a warning suggesting using <coroutine> instead of <experimental/coroutine>

Then you should be able to land the compiler change and it should continue to have the same behaviour for existing code using std::experimental:: types with the existing stdlib.
It is only once the stdlib changes that land which add the <coroutine> header that users would start seeing the warnings about using <coroutine> instead of <experimental/coroutine>

Note that there are still some potential breakages for code that could go on here, however.

Imagine that some header I included has been updated to use <coroutine> while my current header is still using <experimental/coroutine> so that both are in scope.

I might have defined an awaitable type that looks like the following:

c++
#include <other/header.hpp> // which transitively includes <coroutine>
#include <experimental/coroutine>

struct my_awaitable {
  bool await_ready();
  void await_suspend(std::experimental::coroutine_handle<> coro);
  void await_resume();
};

In this case, the compiler would find the std::coroutine_handle<> and try to instantiate the await-suspend expression with that type, which would fail because await_suspend() is not callable with a std::coroutine_handle.
The compiler would need to fall back to instantiating the expression with std::experimental::coroutine_handle<P>.

There is also the variation where await_suspend() is a template function that deduces the promise-type argument.
e.g.

c++
template<typename Promise>
void await_suspend(std::experimental::coroutine_handle<Promise> coro);

There are also cases where the template parameter to await_suspend() is unconstrained.
e.g.

c++
struct promise_type {
  ...
  std::experimental::coroutine_handle<> continuation;
};

struct my_awaitable {
  bool await_ready();
  template<typename CoroHandle>
  auto await_suspend(CoroHandle handle) {
    coro.promise().continuation = handle;
    return coro;
  }
  void await_resume();

  std::experimental::coroutine_handle<promise_type> coro;
};

Such a type would successfully deduce the template parameter using std::coroutine_handle and so the await-suspend expression would be valid, but the instantiation of the await_suspend() body would fail as a std::coroutine_handle<P> cannot be assigned to an lvalue of type std::experimentl::coroutine_handle<>. This would not produce a SFINAE-friendly error that the compiler could retry with std::experimental types.

I'm not sure if there's a great way of keeping such code working in a mixed <coroutine> and <experimental/coroutine> world.
Maybe the cost of doing so is not worth the benefit?

The only way I can think of making this work is to just make std::experimental::* an alias for std::*.
But that only works for std::experimental::coroutine_handle. It doesn't work for std::experimental::coroutine_traits as you can't add specialisations through an alias.

[ChuanqiXu]

In D108696#3086011, @lewissbaker wrote:

So am I correct in understanding that the main issue with the chicken/egg problem for updating both the compiler to use the new stdlib facilities and updating the stdlib facilities is that we don't want to issue warnings about using <experimental/coroutine> and telling users to use <coroutine> instead if there is no <coroutine> header.

I wonder if a suitable transition approach here might be to have the compiler do:

• try lookup of std::coroutine_handle/coroutine_traits; if found try to instantiate the expression (e.g. await-suspend) using the std:: type
• if not found then try lookup of std::experimental::coroutine_handle/coroutine_traits; and if found try to instantiate the expression using the std::experimental:: type; and if successful, then;
  • if std:: type was found but instantiating the expression failed, then issue a warning about using deprecated std::experimental:: types
  • otherwise if std:: type was not found, try to find <coroutine> header and if present then issue a warning suggesting using <coroutine> instead of <experimental/coroutine>

Then you should be able to land the compiler change and it should continue to have the same behaviour for existing code using std::experimental:: types with the existing stdlib.
It is only once the stdlib changes that land which add the <coroutine> header that users would start seeing the warnings about using <coroutine> instead of <experimental/coroutine>

It looks odd for me with the sentence:

otherwise if std:: type was not found, try to find <coroutine> header and if present then issue a warning suggesting using <coroutine> instead of <experimental/coroutine>

If we could find the <coroutine> header, we should be able to find std::coro* types. Otherwise, the <coroutine> header is fake.

My transition plan would be:

• Land this.
• Land D109433, it is the change who added <coroutine>.
• Land another patch in clang to issue a warning for the deprecated use of <experimental/coroutine>. The reason why we need to split this with the first step is that we don't want to trigger the CI system for libc++. (It's the reason this patch is rejected before).
• Remove <experimental/coroutine> in libcxx in LLVM15.
• Remove the support for std::experimental::coro* in clang in LLVM16.

Note that there are still some potential breakages for code that could go on here, however.

Imagine that some header I included has been updated to use <coroutine> while my current header is still using <experimental/coroutine> so that both are in scope.

I might have defined an awaitable type that looks like the following:

c++
#include <other/header.hpp> // which transitively includes <coroutine>
#include <experimental/coroutine>

struct my_awaitable {
  bool await_ready();
  void await_suspend(std::experimental::coroutine_handle<> coro);
  void await_resume();
};

In this case, the compiler would find the std::coroutine_handle<> and try to instantiate the await-suspend expression with that type, which would fail because await_suspend() is not callable with a std::coroutine_handle.
The compiler would need to fall back to instantiating the expression with std::experimental::coroutine_handle<P>.

My personal opinion is that this case should fail instead of requiring the compiler to fall back to instantiating with std::experimental::coro*. There are two reasons:

• It is not easy to implement such fall back to instantiating logics. It would make the current search process much more complex.
• It is not worth to do so in my opinion. Since <experimental/coroutine> is the deprecated use. It is odd for me that we need to do extra work to conform it.

There is also the variation where await_suspend() is a template function that deduces the promise-type argument.
e.g.

c++
template<typename Promise>
void await_suspend(std::experimental::coroutine_handle<Promise> coro);

There are also cases where the template parameter to await_suspend() is unconstrained.
e.g.

c++
struct promise_type {
  ...
  std::experimental::coroutine_handle<> continuation;
};

struct my_awaitable {
  bool await_ready();
  template<typename CoroHandle>
  auto await_suspend(CoroHandle handle) {
    coro.promise().continuation = handle;
    return coro;
  }
  void await_resume();

  std::experimental::coroutine_handle<promise_type> coro;
};

Such a type would successfully deduce the template parameter using std::coroutine_handle and so the await-suspend expression would be valid, but the instantiation of the await_suspend() body would fail as a std::coroutine_handle<P> cannot be assigned to an lvalue of type std::experimentl::coroutine_handle<>. This would not produce a SFINAE-friendly error that the compiler could retry with std::experimental types.

I'm not sure if there's a great way of keeping such code working in a mixed <coroutine> and <experimental/coroutine> world.
Maybe the cost of doing so is not worth the benefit?

Thanks for offering these examples. It is valuable. But I think the root cause may be the mixed use for <coroutine> and <experimental/coroutine>. It is too bad.
IMHO, it is not worth to do so.

The only way I can think of making this work is to just make std::experimental::* an alias for std::*.
But that only works for std::experimental::coroutine_handle. It doesn't work for std::experimental::coroutine_traits as you can't add specialisations through an alias.

Yes, the compiler would look up to std::experimental::coroutine_traits to get the namespace used. We have talked about the method to make std::experimental::* to be an alias for std::*. It should be done in libcxx part. And it is not valid since it doesn't obey the rule.
Originally, I am changing <experimental/coroutine> directly. But then I am required to keep <experimental/coroutine> untouched. It makes sense to me so I didn't complain about that.

IMO, the key point here is that if the mixed use of <coroutine> and <experimental/coroutine> need to be considered. I think we could get rid of it personally.

[ChuanqiXu]

Address the comments in coroutines-exp-namespace.cpp.

[• Quuxplusone]

@lewissbaker wrote:

#include <other/header.hpp> // which transitively includes <coroutine>
#include <experimental/coroutine>

Good example! I had not previously been thinking about transitive includes. I believe we "obviously" don't need to cater to code that manually includes both <coroutine> and <experimental/coroutine> in the same source file; but transitive includes are vastly more likely to happen in practice, and so if we're not going to care about them, that's a policy decision. Might still be a good tradeoff, to break some code in the short term in exchange for a simpler compiler (also in the short term), but its goodness is not obvious.

The only way I can think of making this work is to just make std::experimental::* an alias for std::*.
But that only works for std::experimental::coroutine_handle. It doesn't work for std::experimental::coroutine_traits as you can't add specialisations through an alias.

We could use a using-declaration to bring std::coroutine_traits into namespace std::experimental. That works, and you can still add specializations for std::experimental::coroutine_traits<U> because that's just a name that looks-up-to the same template. https://godbolt.org/z/fWGrT5js5 However, as shown in that godbolt, this would have the (salutary) effect of breaking users who are out there (in the year of our lord 2021!) still reopening namespace std just to add a template specialization.

But! My understanding is that the only reason we're keeping <experimental/coroutine> alive at all, in 14.x, is to provide continuity for its users and not break their existing code right away. If we go changing the API of <experimental/coroutine> (by aliasing it to <coroutine>), then we do break those users right away (because their code depends on the old experimental API, not the new conforming one). So "alias it to <coroutine>" doesn't seem like a viable path forward, anyway. (Also, <coroutine> wants to use C++20-only features, but <experimental/coroutine> must continue to work in C++14.) I think we need to start from the premise that <experimental/coroutine> and <coroutine> will have different APIs; and if that makes it difficult to support Lewis's very reasonable transitive-include scenario, then we have to either implement something difficult, or else make a policy decision that 14.x simply won't support translation units that transitively include both APIs. (15.x certainly will not support such TUs, because it won't support any TUs that include <experimental/coroutine>, transitively or otherwise.)

IOW, it sounds like we're all (@ChuanqiXu @lewissbaker @Quuxplusone) reluctantly OK with the resolution "Do not support translation units that transitively include both APIs"; but it would be helpful to have someone more authoritative weigh in (with either "yes that's OK policy" or "no we need to find some other solution"), if such a person is watching.

clang/docs/LanguageExtensions.rst

2872

to implement the ``std::coroutine_handle`` type.

clang/include/clang/Basic/DiagnosticSemaKinds.td

11002

Pre-existing: It's weird that the surrounding messages are of the form "foo must be bar," and then this one is "foo isn't baz". This message could be re-worded as std::coroutine_handle must have a member named '%0' for consistency. (But that might be out of scope for this PR.)

clang/include/clang/Sema/Sema.h

10274

s/would be/is/

clang/lib/Sema/SemaCoroutine.cpp

1668

/// Look up in namespace std::experimental, for compatibility.
/// TODO: Remove this extra lookup when <experimental/coroutine> is removed.

(The extra lookup is done, not TODO. The removal is the TODO part. Also, grammar nits.)

clang/test/AST/coroutine-source-location-crash.cpp

12–14

Thanks for adding -exp-namespace versions of the Sema tests. I think you should do the same for all of these tests as well, for the same reason: we don't want to remove test coverage related to std::experimental until those codepaths are actually gone.

Also, just as a practical matter: This test says it runs in c++14 mode, but our actual std::coroutine_handle relies on C++20isms. So, my conclusion is that right now you've got a file Inputs/std-coroutine.h that is claiming to be a mockup of libc++'s std::coroutine_handle, but actually is a mockup of std::experimental::coroutine_handle. That's going to be really confusing. I think we need both Inputs/std-experimental-coroutine.h and Inputs/std-coroutine.h, and we need -exp-namespace copies of all these tests too.

As a bonus, this will also allow you to test the compiler's behavior on a TU like

#include "Inputs/std-coroutine.h"
#include "Inputs/std-experimental-coroutine.h"

struct my_awaitable {
  bool await_ready();
  // expected-error@1 {{'await_suspend' must be callable with 'std::coroutine_handle<>' or whatever}}
  void await_suspend(std::experimental::coroutine_handle<> coro);
  void await_resume();
};

in order to prove (and regression-test) that the compiler does not "support" this scenario but also does not crash!

[ChuanqiXu]

Changes includes:

• Add -exp-namespace copies for all of these tests.
• Add an error if detected mixed use of std:: and std::experimental.
• Add test for mixed use of std:: and std::experimental:: namespaces.
• Run all non exp-namespaces tests in C++20 mode.
• Other wordy changes.

[ChuanqiXu]

In D108696#3090484, @Quuxplusone wrote:

@lewissbaker wrote:

#include <other/header.hpp> // which transitively includes <coroutine>
#include <experimental/coroutine>

Good example! I had not previously been thinking about transitive includes. I believe we "obviously" don't need to cater to code that manually includes both <coroutine> and <experimental/coroutine> in the same source file; but transitive includes are vastly more likely to happen in practice, and so if we're not going to care about them, that's a policy decision. Might still be a good tradeoff, to break some code in the short term in exchange for a simpler compiler (also in the short term), but its goodness is not obvious.

The only way I can think of making this work is to just make std::experimental::* an alias for std::*.
But that only works for std::experimental::coroutine_handle. It doesn't work for std::experimental::coroutine_traits as you can't add specialisations through an alias.

We could use a using-declaration to bring std::coroutine_traits into namespace std::experimental. That works, and you can still add specializations for std::experimental::coroutine_traits<U> because that's just a name that looks-up-to the same template. https://godbolt.org/z/fWGrT5js5 However, as shown in that godbolt, this would have the (salutary) effect of breaking users who are out there (in the year of our lord 2021!) still reopening namespace std just to add a template specialization.

But! My understanding is that the only reason we're keeping <experimental/coroutine> alive at all, in 14.x, is to provide continuity for its users and not break their existing code right away. If we go changing the API of <experimental/coroutine> (by aliasing it to <coroutine>), then we do break those users right away (because their code depends on the old experimental API, not the new conforming one). So "alias it to <coroutine>" doesn't seem like a viable path forward, anyway. (Also, <coroutine> wants to use C++20-only features, but <experimental/coroutine> must continue to work in C++14.) I think we need to start from the premise that <experimental/coroutine> and <coroutine> will have different APIs; and if that makes it difficult to support Lewis's very reasonable transitive-include scenario, then we have to either implement something difficult, or else make a policy decision that 14.x simply won't support translation units that transitively include both APIs. (15.x certainly will not support such TUs, because it won't support any TUs that include <experimental/coroutine>, transitively or otherwise.)

IOW, it sounds like we're all (@ChuanqiXu @lewissbaker @Quuxplusone) reluctantly OK with the resolution "Do not support translation units that transitively include both APIs"; but it would be helpful to have someone more authoritative weigh in (with either "yes that's OK policy" or "no we need to find some other solution"), if such a person is watching.

Yeah, the last key point here may be the problem that how do we treat for programs which contains both APIs. Since there are other experimental/* headers moved in to normal include paths, I guess there may be similar problems before. I think this problem is not limited in coroutine. So how does libc++ do before for this situation @Quuxplusone ?

Since it looks like that people here may agree that we don't support both APIs. So I add an error if the compiler founds the mixed use of std::coro* and std::experimental::coro*. I think this is the best we could do if we decide to not support it.

clang/include/clang/Basic/DiagnosticSemaKinds.td

11002

Oh, many thanks for the detailed reviews. I edit this to the way you introduced. Otherwise we couldn't remember this defect after this patch.

[ChuanqiXu]

Implement __cpp_impl_coroutine feature macro.

[• Quuxplusone]

In D108696#3095789, @ChuanqiXu wrote:

Since there are other experimental/* headers moved in to normal include paths, I guess there may be similar problems before. I think this problem is not limited in coroutine. So how does libc++ do before for this situation @Quuxplusone ?

I'm not aware of any similar situations involving <experimental/*>. Most stuff in <experimental/*> is just library stuff, like std::experimental::pmr, where the two versions can happily coexist because we have namespaces. Coroutines are special (and really annoying) because they're a core-language feature with a "magic" relationship to a specific library header. (Core-language syntax doesn't respect namespaces.) The only other "magic" features like that are

• typeid looks for std::type_info
• {} looks for std::initializer_list
• auto [a,b] looks for std::tuple_size etc.
• <=> looks for std::strong_ordering etc.

None of these were ever prototyped in <experimental/*> before being put into the Standard, so they never ran into this problem.

[ChuanqiXu]

In D108696#3096822, @Quuxplusone wrote:

In D108696#3095789, @ChuanqiXu wrote:

Since there are other experimental/* headers moved in to normal include paths, I guess there may be similar problems before. I think this problem is not limited in coroutine. So how does libc++ do before for this situation @Quuxplusone ?

I'm not aware of any similar situations involving <experimental/*>. Most stuff in <experimental/*> is just library stuff, like std::experimental::pmr, where the two versions can happily coexist because we have namespaces. Coroutines are special (and really annoying) because they're a core-language feature with a "magic" relationship to a specific library header. (Core-language syntax doesn't respect namespaces.) The only other "magic" features like that are

• typeid looks for std::type_info
• {} looks for std::initializer_list
• auto [a,b] looks for std::tuple_size etc.
• <=> looks for std::strong_ordering etc.

None of these were ever prototyped in <experimental/*> before being put into the Standard, so they never ran into this problem.

Oh, got it. So now is the time to do policy decision and the community didn't meet similar problem before. Here is my reason for not supporting both:

• It is complex to implement.
• It would be removed in recent future. Complexity is not a very strong reason to refuse a need. But it is frustrating to implement a feature which would be removed in a predictable recent future.
• From the perspective of users, it shouldn't be hard to switch from std::experimental::coro* to std::coro*. I write coroutine codes in production too. AFAIK, it should be easy. (I understand that I couldn't stand for all the users)

Here are my reasons. But if we couldn't get in consensus. I guess we could only post this to cfe-dev to ask more people for involving in.

[lxfind]

I also agree that we should try to keep the compiler simple and not support the complicated case.
It should be fairly straightforward for a codebase to update fully to use std instead of std::experimental (we have a large coroutine codebase as well).
Given that everyone is mostly supportive, I will accept the change.

[ChuanqiXu]

@lxfind @Quuxplusone @lewissbaker Thanks for looking into this!
I have committed this. Since the remained problem is that whether or not should we support the case that user uses "std::coroutine*" and "std::experimental::coroutine*" at the same time.
As the reason we stated above, it is hard to implement and the help is limited. Even in the case that someone points out necessary and strong reasons that we need to support both "std::coroutine*" and "std:::experimental::coroutine". We could support it in later patches.

clang-tools-extra/test/clang-tidy/checkers/Inputs/readability-identifier-naming/system/coroutines.h

 #pragma once
 
 namespace std {
-namespace experimental {
 
 template <typename ret_t, typename... args_t>
 struct coroutine_traits {
   using promise_type = typename ret_t::promise_type;
 };
 
 template <class promise_t>
 struct coroutine_handle {
   static constexpr coroutine_handle from_address(void *addr) noexcept { return {}; };
 };
 
-} // namespace experimental
 } // namespace std
 
 struct never_suspend {
   bool await_ready() noexcept { return false; }
   template <typename coro_t>
   void await_suspend(coro_t handle) noexcept {}
   void await_resume() noexcept {}
 };

clang/docs/LanguageExtensions.rst

 --------------------------------
 
 .. warning::
   This is a work in progress. Compatibility across Clang/LLVM releases is not
   guaranteed.
 
 Clang provides experimental builtins to support C++ Coroutines as defined by
 https://wg21.link/P0057. The following four are intended to be used by the
-standard library to implement `std::experimental::coroutine_handle` type.
+standard library to implement `std::coroutine_handle` type.
 
 **Syntax**:
 
 .. code-block:: c
 
   void  __builtin_coro_resume(void *addr);
   void  __builtin_coro_destroy(void *addr);
   bool  __builtin_coro_done(void *addr);

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_coroutine_outside_function : Error<
   "'%0' cannot be used outside a function">;
 def err_coroutine_invalid_func_context : Error<
   "'%1' cannot be used in %select{a constructor|a destructor"
   "|the 'main' function|a constexpr function"
   "|a function with a deduced return type|a varargs function"
   "|a consteval function}0">;
 def err_implied_coroutine_type_not_found : Error<
-  "%0 type was not found; include <experimental/coroutine> before defining "
-  "a coroutine">;
+  "%0 type was not found; include <coroutine> before defining "
+  "a coroutine; include <experimental/coroutine> if your version "
+  "of libcxx is less than 14.0">;
 def err_implicit_coroutine_std_nothrow_type_not_found : Error<
   "std::nothrow was not found; include <new> before defining a coroutine which "
   "uses get_return_object_on_allocation_failure()">;
 def err_malformed_std_nothrow : Error<
   "std::nothrow must be a valid variable declaration">;
 def err_malformed_std_coroutine_handle : Error<
-  "std::experimental::coroutine_handle must be a class template">;
+  "std::coroutine_handle must be a class template">;
 def err_coroutine_handle_missing_member : Error<
-  "std::experimental::coroutine_handle missing a member named '%0'">;
+  "std::coroutine_handle missing a member named '%0'">;
 def err_malformed_std_coroutine_traits : Error<
-  "'std::experimental::coroutine_traits' must be a class template">;
+  "'std::coroutine_traits' must be a class template">;
 def err_implied_std_coroutine_traits_promise_type_not_found : Error<
   "this function cannot be a coroutine: %q0 has no member named 'promise_type'">;
 def err_implied_std_coroutine_traits_promise_type_not_class : Error<
   "this function cannot be a coroutine: %0 is not a class">;
 def err_coroutine_promise_type_incomplete : Error<
   "this function cannot be a coroutine: %0 is an incomplete type">;
 def err_coroutine_type_missing_specialization : Error<
   "this function cannot be a coroutine: missing definition of "
   "specialization %0">;
 def err_coroutine_promise_incompatible_return_functions : Error<
   "the coroutine promise type %0 declares both 'return_value' and 'return_void'">;
 def err_coroutine_promise_requires_return_function : Error<
   "the coroutine promise type %0 must declare either 'return_value' or 'return_void'">;
 def note_coroutine_promise_implicit_await_transform_required_here : Note<
   "call to 'await_transform' implicitly required by 'co_await' here">;
 def note_coroutine_promise_suspend_implicitly_required : Note<
   "call to '%select{initial_suspend|final_suspend}0' implicitly "
   "required by the %select{initial suspend point|final suspend point}0">;
 def err_coroutine_promise_unhandled_exception_required : Error<

clang/include/clang/Sema/Sema.h

public:
 
   /// The C++ "std::initializer_list" template, which is defined in
   /// \<initializer_list>.
   ClassTemplateDecl *StdInitializerList;
 
   /// The C++ "std::coroutine_traits" template, which is defined in
   /// \<coroutine_traits>
   ClassTemplateDecl *StdCoroutineTraitsCache;
+  /// The namespace where coroutine components are defined. In standard,
+  /// they are defined in std namespace. And in the previous implementation,
+  /// they are defined in std::experimental namespace.
+  NamespaceDecl *CoroTraitsNamespaceCache;
 
   /// The C++ "type_info" declaration, which is defined in \<typeinfo>.
   RecordDecl *CXXTypeInfoDecl;
 
   /// The MSVC "_GUID" struct, which is defined in MSVC header files.
   RecordDecl *MSVCGuidDecl;
 
   /// Caches identifiers/selectors for NSFoundation APIs.
Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
                                const ParsedAttributesView &AttrList,
                                UsingDirectiveDecl *&UsingDecl);
   void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
 
   NamespaceDecl *getStdNamespace() const;
   NamespaceDecl *getOrCreateStdNamespace();
 
   NamespaceDecl *lookupStdExperimentalNamespace();
+  NamespaceDecl *getCachedCoroNamespace() { return CoroTraitsNamespaceCache; }
 
   CXXRecordDecl *getStdBadAlloc() const;
   EnumDecl *getStdAlignValT() const;
 
 private:
   // A cache representing if we've fully checked the various comparison category
   // types stored in ASTContext. The bit-index corresponds to the integer value
   // of a ComparisonCategoryType enumerator.
ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
                                         UnresolvedLookupExpr* Lookup);
   ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
   StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
                                bool IsImplicit = false);
   StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);
   bool buildCoroutineParameterMoves(SourceLocation Loc);
   VarDecl *buildCoroutinePromise(SourceLocation Loc);
   void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);
+  /// Lookup 'coroutine_traits' in std namespace and std::experimental
+  /// namespace. The namespace found would be recorded in Namespace.
   ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc,
-                                           SourceLocation FuncLoc);
+                                           SourceLocation FuncLoc,
+                                           NamespaceDecl *&Namespace);
   /// Check that the expression co_await promise.final_suspend() shall not be
   /// potentially-throwing.
   bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend);
 
   //===--------------------------------------------------------------------===//
   // OpenMP directives and clauses.
   //
 private:

clang/lib/Sema/SemaCoroutine.cpp

 }
 
 /// Look up the std::coroutine_traits<...>::promise_type for the given
 /// function type.
 static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD,
                                   SourceLocation KwLoc) {
   const FunctionProtoType *FnType = FD->getType()->castAs<FunctionProtoType>();
   const SourceLocation FuncLoc = FD->getLocation();
-  // FIXME: Cache std::coroutine_traits once we've found it.
-  NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
-  if (!StdExp) {
-    S.Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
-        << "std::experimental::coroutine_traits";
-    return QualType();
-  }
 
-  ClassTemplateDecl *CoroTraits = S.lookupCoroutineTraits(KwLoc, FuncLoc);
+  NamespaceDecl *CoroNamespace = nullptr;
+  ClassTemplateDecl *CoroTraits =
+      S.lookupCoroutineTraits(KwLoc, FuncLoc, CoroNamespace);
   if (!CoroTraits) {
     return QualType();
   }
 
   // Form template argument list for coroutine_traits<R, P1, P2, ...> according
   // to [dcl.fct.def.coroutine]3
   TemplateArgumentListInfo Args(KwLoc, KwLoc);
   auto AddArg = [&](QualType T) {
S.Diag(FuncLoc,
            diag::err_implied_std_coroutine_traits_promise_type_not_found)
         << RD;
     return QualType();
   }
   // The promise type is required to be a class type.
   QualType PromiseType = S.Context.getTypeDeclType(Promise);
 
   auto buildElaboratedType = [&]() {
-    auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, StdExp);
+    auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, CoroNamespace);
     NNS = NestedNameSpecifier::Create(S.Context, NNS, false,
                                       CoroTrait.getTypePtr());
     return S.Context.getElaboratedType(ETK_None, NNS, PromiseType);
   };
 
   if (!PromiseType->getAsCXXRecordDecl()) {
     S.Diag(FuncLoc,
            diag::err_implied_std_coroutine_traits_promise_type_not_class)
         << buildElaboratedType();
     return QualType();
   }
   if (S.RequireCompleteType(FuncLoc, buildElaboratedType(),
                             diag::err_coroutine_promise_type_incomplete))
     return QualType();
 
   return PromiseType;
 }
 
-/// Look up the std::experimental::coroutine_handle<PromiseType>.
+/// Look up the std::coroutine_handle<PromiseType>.
 static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType,
                                           SourceLocation Loc) {
   if (PromiseType.isNull())
     return QualType();
 
-  NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
-  assert(StdExp && "Should already be diagnosed");
+  NamespaceDecl *CoroNamespace = S.getCachedCoroNamespace();
+  assert(CoroNamespace && "Should already be diagnosed");
 
   LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_handle"),
                       Loc, Sema::LookupOrdinaryName);
-  if (!S.LookupQualifiedName(Result, StdExp)) {
+  if (!S.LookupQualifiedName(Result, CoroNamespace)) {
     S.Diag(Loc, diag::err_implied_coroutine_type_not_found)
-        << "std::experimental::coroutine_handle";
+        << "std::coroutine_handle";
     return QualType();
   }
 
   ClassTemplateDecl *CoroHandle = Result.getAsSingle<ClassTemplateDecl>();
   if (!CoroHandle) {
     Result.suppressDiagnostics();
     // We found something weird. Complain about the first thing we found.
     NamedDecl *Found = *Result.begin();

 /// Look up the std::nothrow object.
 static Expr *buildStdNoThrowDeclRef(Sema &S, SourceLocation Loc) {
   NamespaceDecl *Std = S.getStdNamespace();
   assert(Std && "Should already be diagnosed");
 
   LookupResult Result(S, &S.PP.getIdentifierTable().get("nothrow"), Loc,
                       Sema::LookupOrdinaryName);
   if (!S.LookupQualifiedName(Result, Std)) {
-    // FIXME: <experimental/coroutine> should have been included already.
+    // FIXME: <coroutine> should have been included already.
     // If we require it to include <new> then this diagnostic is no longer
     // needed.
     S.Diag(Loc, diag::err_implicit_coroutine_std_nothrow_type_not_found);
     return nullptr;
   }
 
   auto *VD = Result.getAsSingle<VarDecl>();
   if (!VD) {

 StmtResult Sema::BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
   CoroutineBodyStmt *Res = CoroutineBodyStmt::Create(Context, Args);
   if (!Res)
     return StmtError();
   return Res;
 }
 
 ClassTemplateDecl *Sema::lookupCoroutineTraits(SourceLocation KwLoc,
-                                               SourceLocation FuncLoc) {
+                                               SourceLocation FuncLoc,
+                                               NamespaceDecl *&Namespace) {
   if (!StdCoroutineTraitsCache) {
-    if (auto StdExp = lookupStdExperimentalNamespace()) {
-      LookupResult Result(*this,
-                          &PP.getIdentifierTable().get("coroutine_traits"),
-                          FuncLoc, LookupOrdinaryName);
-      if (!LookupQualifiedName(Result, StdExp)) {
+    NamespaceDecl *CoroNamespace = getStdNamespace();
+    LookupResult Result(*this, &PP.getIdentifierTable().get("coroutine_traits"),
+    if (!CoroNamespace || !LookupQualifiedName(Result, CoroNamespace)) {
+      /// TODO: Lookup in std::experimental namespace for compability.
+      /// Remove this once users get familiar with coroutine under std
+      /// namespace.
+      CoroNamespace = lookupStdExperimentalNamespace();
+      if (!CoroNamespace || !LookupQualifiedName(Result, CoroNamespace)) {
         Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
-            << "std::experimental::coroutine_traits";
+            << "std::coroutine_traits";
         return nullptr;
       }
-      if (!(StdCoroutineTraitsCache =
-                Result.getAsSingle<ClassTemplateDecl>())) {
-        Result.suppressDiagnostics();
-        NamedDecl *Found = *Result.begin();
-        Diag(Found->getLocation(), diag::err_malformed_std_coroutine_traits);
-        return nullptr;
-      }
-    }
-  }
+      /// TODO: Add a warning about not including <experimental/coroutine>
+      /// once we update libcxx.
+    }
+    if (!(StdCoroutineTraitsCache = Result.getAsSingle<ClassTemplateDecl>())) {
+    CoroTraitsNamespaceCache = CoroNamespace;
+  Namespace = CoroTraitsNamespaceCache;
   return StdCoroutineTraitsCache;
 }

clang/test/AST/Inputs/std-coroutine.h

 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wno-unreachable-code -Wno-unused-value
 #ifndef STD_COROUTINE_H
 #define STD_COROUTINE_H
 
 namespace std {
-namespace experimental {
 
 template <typename R, typename...> struct coroutine_traits {
   using promise_type = typename R::promise_type;
 };
 
 template <typename Promise = void> struct coroutine_handle;
 
 template <> struct coroutine_handle<void> {

 };
 
 struct suspend_never {
   bool await_ready() noexcept { return true; }
   void await_suspend(coroutine_handle<>) noexcept {}
   void await_resume() noexcept {}
 };
 
-} // namespace experimental
 } // namespace std
 
 #endif // STD_COROUTINE_H

clang/test/AST/coroutine-locals-cleanup.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -fsyntax-only -ast-dump %s | FileCheck %s
 
 #include "Inputs/std-coroutine.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct Task {
   struct promise_type {
     Task get_return_object() noexcept {
       return Task{coroutine_handle<promise_type>::from_promise(*this)};
     }
 
     void return_void() noexcept {}

clang/test/AST/coroutine-source-location-crash.cpp

 // Test without serialization:
 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
 // RUN:    -fsyntax-only -ast-dump | FileCheck %s
 //
 // Test with serialization:
 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 -std=c++14 -fcoroutines-ts -emit-pch -o %t %s
 // RUN: %clang_cc1 -x c++ -triple x86_64-apple-darwin9 -std=c++14 -fcoroutines-ts -include-pch %t \
 // RUN: -ast-dump-all /dev/null \
 // RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
 // RUN: | FileCheck %s
 
 #include "Inputs/std-coroutine.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct A {
   bool await_ready();
   void await_resume();
   template <typename F>
   void await_suspend(F);
 };
 

clang/test/Analysis/more-dtors-cfg-output.cpp

 // CHECK: void new_default_ctor_with_default_arg(long count)
 // CHECK: CXXConstructExpr, {{.*}}, struct DefaultArgInCtor[]
 // CXX14: ~Foo() (Temporary object destructor)
 // CHECK: ~Foo() (Temporary object destructor)
 
 #if CXX2A
 // Boilerplate needed to test co_return:
 
-namespace std::experimental {
-  template <typename Promise>
-  struct coroutine_handle {
-    static coroutine_handle from_address(void *) noexcept;
-  };
-}
+namespace std {
+} // namespace std
 
 struct TestPromise {
   TestPromise initial_suspend();
   TestPromise final_suspend() noexcept;
   bool await_ready() noexcept;
-  void await_suspend(const std::experimental::coroutine_handle<TestPromise> &) noexcept;
+  void await_suspend(const std::coroutine_handle<TestPromise> &) noexcept;
   void await_resume() noexcept;
   Foo return_value(const Bar &);
   Bar get_return_object();
   void unhandled_exception();
 };
 
-namespace std::experimental {
-  template <typename Ret, typename... Args>
-  struct coroutine_traits;
-  template <>
-  struct coroutine_traits<Bar> {
-      using promise_type = TestPromise;
-  };
-}
+namespace std {
+} // namespace std
 
 Bar coreturn() {
   co_return get_bar();
   // This expands to something like:
   //     promise.return_value(get_bar());
   // get_bar() is passed by reference to return_value() and is then destroyed;
   // there is no equivalent of RVO.  TestPromise::return_value also returns a
   // Foo, which should be immediately destroyed.
   // FIXME: The generated CFG completely ignores get_return_object().
 }
 // CXX2A: Bar coreturn()
 // CXX2A: ~Foo() (Temporary object destructor)
 // CXX2A: ~Bar() (Temporary object destructor)
 #endif

clang/test/CodeGenCXX/ubsan-coroutines.cpp

 // This test merely verifies that emitting the object file does not cause a
 // crash when the LLVM coroutines passes are run.
 // RUN: %clang_cc1 -emit-obj -std=c++2a -fsanitize=null %s -o %t.o
 
-namespace std::experimental {
+namespace std {
 template <typename R, typename... T> struct coroutine_traits {
   using promise_type = typename R::promise_type;
 };
 
 template <class Promise = void> struct coroutine_handle;
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
 template <class Promise> struct coroutine_handle : coroutine_handle<void> {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
 struct task {
   struct promise_type {
     task get_return_object() { return task(); }
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception() {}
   };
 };
 
 struct awaitable {
   task await() { (void)co_await *this; }
   bool await_ready() { return false; }
-  bool await_suspend(std::experimental::coroutine_handle<> awaiter) { return false; }
+  bool await_suspend(std::coroutine_handle<> awaiter) { return false; }
   bool await_resume() { return false; }
 };
 
 int main() {
   awaitable a;
   a.await();
 }

clang/test/CodeGenCoroutines/Inputs/coroutine.h

 #pragma once
 
-namespace std { namespace experimental { inline namespace coroutines_v1 {
+namespace std {
 
 template <typename R, typename...> struct coroutine_traits {
   using promise_type = typename R::promise_type;
 };
 
 template <typename Promise = void> struct coroutine_handle;
 
 template <> struct coroutine_handle<void> {
struct suspend_always {
   void await_resume() {}
 };
 struct suspend_never {
   bool await_ready() noexcept { return true; }
   void await_suspend(coroutine_handle<>) noexcept {}
   void await_resume() noexcept {}
 };
 
-}}}
+} // namespace std

clang/test/CodeGenCoroutines/coro-alloc.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 \
 // RUN:    -Wno-coroutine-missing-unhandled-exception -emit-llvm %s -o - -disable-llvm-passes \
 // RUN:   | FileCheck %s
 
 namespace std {
-namespace experimental {
 template <typename... T>
 struct coroutine_traits; // expected-note {{declared here}}
 
 template <class Promise = void>
 struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept { return {}; }
 };
 
 template <>
 struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) { return {}; }
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept {}
 };
 
-} // end namespace experimental
-
 struct nothrow_t {};
 constexpr nothrow_t nothrow = {};
 
 } // end namespace std
 
 // Required when get_return_object_on_allocation_failure() is defined by
 // the promise.
 using SizeT = decltype(sizeof(int));
 void* operator new(SizeT __sz, const std::nothrow_t&) noexcept;
 void  operator delete(void* __p, const std::nothrow_t&) noexcept;
 
 
 struct suspend_always {
   bool await_ready() noexcept { return false; }
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept {}
+  void await_suspend(std::coroutine_handle<>) noexcept {}
   void await_resume() noexcept {}
 };
 
 struct global_new_delete_tag {};
 
-template<>
-struct std::experimental::coroutine_traits<void, global_new_delete_tag> {
+template <>
+struct std::coroutine_traits<void, global_new_delete_tag> {
   struct promise_type {
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
   };
 };
 
extern "C" void f0(global_new_delete_tag) {
 
   // CHECK: [[Afterwards]]:
   // CHECK: ret void
   co_return;
 }
 
 struct promise_new_tag {};
 
-template<>
-struct std::experimental::coroutine_traits<void, promise_new_tag> {
+template <>
+struct std::coroutine_traits<void, promise_new_tag> {
   struct promise_type {
     void *operator new(unsigned long);
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
   };
 };
 
 // CHECK-LABEL: f1(
 extern "C" void f1(promise_new_tag ) {
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
-  // CHECK: call i8* @_ZNSt12experimental16coroutine_traitsIJv15promise_new_tagEE12promise_typenwEm(i64 %[[SIZE]])
+  // CHECK: call i8* @_ZNSt16coroutine_traitsIJv15promise_new_tagEE12promise_typenwEm(i64 %[[SIZE]])
 
   // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
   // CHECK: %[[MEM:.+]] = call i8* @llvm.coro.free(token %[[ID]], i8* %[[FRAME]])
   // CHECK: call void @_ZdlPv(i8* %[[MEM]])
   co_return;
 }
 
 struct promise_matching_placement_new_tag {};
 
-template<>
-struct std::experimental::coroutine_traits<void, promise_matching_placement_new_tag, int, float, double> {
+template <>
+struct std::coroutine_traits<void, promise_matching_placement_new_tag, int, float, double> {
   struct promise_type {
     void *operator new(unsigned long, promise_matching_placement_new_tag,
                        int, float, double);
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
   };
 };
 
 // CHECK-LABEL: f1a(
 extern "C" void f1a(promise_matching_placement_new_tag, int x, float y , double z) {
   // CHECK: store i32 %x, i32* %x.addr, align 4
   // CHECK: store float %y, float* %y.addr, align 4
   // CHECK: store double %z, double* %z.addr, align 8
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
   // CHECK: %[[INT:.+]] = load i32, i32* %x.addr, align 4
   // CHECK: %[[FLOAT:.+]] = load float, float* %y.addr, align 4
   // CHECK: %[[DOUBLE:.+]] = load double, double* %z.addr, align 8
-  // CHECK: call i8* @_ZNSt12experimental16coroutine_traitsIJv34promise_matching_placement_new_tagifdEE12promise_typenwEmS1_ifd(i64 %[[SIZE]], i32 %[[INT]], float %[[FLOAT]], double %[[DOUBLE]])
+  // CHECK: call i8* @_ZNSt16coroutine_traitsIJv34promise_matching_placement_new_tagifdEE12promise_typenwEmS0_ifd(i64 %[[SIZE]], i32 %[[INT]], float %[[FLOAT]], double %[[DOUBLE]])
   co_return;
 }
 
 // Declare a placement form operator new, such as the one described in
 // C++ 18.6.1.3.1, which takes a void* argument.
 void* operator new(SizeT __sz, void *__p) noexcept;
 
 struct promise_matching_global_placement_new_tag {};
 struct dummy {};
-template<>
-struct std::experimental::coroutine_traits<void, promise_matching_global_placement_new_tag, dummy*> {
+template <>
+struct std::coroutine_traits<void, promise_matching_global_placement_new_tag, dummy *> {
   struct promise_type {
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
   };
 };
 
 // A coroutine that takes a single pointer argument should not invoke this
 // placement form operator. [dcl.fct.def.coroutine]/7 dictates that lookup for
 // allocation functions matching the coroutine function's signature be done
 // within the scope of the promise type's class.
 // CHECK-LABEL: f1b(
 extern "C" void f1b(promise_matching_global_placement_new_tag, dummy *) {
   // CHECK: call noalias nonnull i8* @_Znwm(i64
   co_return;
 }
 
 struct promise_delete_tag {};
 
-template<>
-struct std::experimental::coroutine_traits<void, promise_delete_tag> {
+template <>
+struct std::coroutine_traits<void, promise_delete_tag> {
   struct promise_type {
     void operator delete(void*);
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
   };
 };
 
 // CHECK-LABEL: f2(
 extern "C" void f2(promise_delete_tag) {
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
   // CHECK: call noalias nonnull i8* @_Znwm(i64 %[[SIZE]])
 
   // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
   // CHECK: %[[MEM:.+]] = call i8* @llvm.coro.free(token %[[ID]], i8* %[[FRAME]])
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJv18promise_delete_tagEE12promise_typedlEPv(i8* %[[MEM]])
+  // CHECK: call void @_ZNSt16coroutine_traitsIJv18promise_delete_tagEE12promise_typedlEPv(i8* %[[MEM]])
   co_return;
 }
 
 struct promise_sized_delete_tag {};
 
-template<>
-struct std::experimental::coroutine_traits<void, promise_sized_delete_tag> {
+template <>
+struct std::coroutine_traits<void, promise_sized_delete_tag> {
   struct promise_type {
     void operator delete(void*, unsigned long);
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
   };
 };
 
 // CHECK-LABEL: f3(
 extern "C" void f3(promise_sized_delete_tag) {
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
   // CHECK: call noalias nonnull i8* @_Znwm(i64 %[[SIZE]])
 
   // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
   // CHECK: %[[MEM:.+]] = call i8* @llvm.coro.free(token %[[ID]], i8* %[[FRAME]])
   // CHECK: %[[SIZE2:.+]] = call i64 @llvm.coro.size.i64()
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJv24promise_sized_delete_tagEE12promise_typedlEPvm(i8* %[[MEM]], i64 %[[SIZE2]])
+  // CHECK: call void @_ZNSt16coroutine_traitsIJv24promise_sized_delete_tagEE12promise_typedlEPvm(i8* %[[MEM]], i64 %[[SIZE2]])
   co_return;
 }
 
 struct promise_on_alloc_failure_tag {};
 
-template<>
-struct std::experimental::coroutine_traits<int, promise_on_alloc_failure_tag> {
+template <>
+struct std::coroutine_traits<int, promise_on_alloc_failure_tag> {
   struct promise_type {
     int get_return_object() { return 0; }
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     static int get_return_object_on_allocation_failure() { return -1; }
   };
 };
 
 // CHECK-LABEL: f4(
 extern "C" int f4(promise_on_alloc_failure_tag) {
   // CHECK: %[[RetVal:.+]] = alloca i32
   // CHECK: %[[Gro:.+]] = alloca i32
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
   // CHECK: %[[MEM:.+]] = call noalias i8* @_ZnwmRKSt9nothrow_t(i64 %[[SIZE]], %"struct.std::nothrow_t"* nonnull align 1 dereferenceable(1) @_ZStL7nothrow)
   // CHECK: %[[OK:.+]] = icmp ne i8* %[[MEM]], null
   // CHECK: br i1 %[[OK]], label %[[OKBB:.+]], label %[[ERRBB:.+]]
 
   // CHECK: [[ERRBB]]:
-  // CHECK:   %[[FailRet:.+]] = call i32 @_ZNSt12experimental16coroutine_traitsIJi28promise_on_alloc_failure_tagEE12promise_type39get_return_object_on_allocation_failureEv(
+  // CHECK:   %[[FailRet:.+]] = call i32 @_ZNSt16coroutine_traitsIJi28promise_on_alloc_failure_tagEE12promise_type39get_return_object_on_allocation_failureEv(
   // CHECK:   store i32 %[[FailRet]], i32* %[[RetVal]]
   // CHECK:   br label %[[RetBB:.+]]
 
   // CHECK: [[OKBB]]:
-  // CHECK:   %[[OkRet:.+]] = call i32 @_ZNSt12experimental16coroutine_traitsIJi28promise_on_alloc_failure_tagEE12promise_type17get_return_objectEv(
+  // CHECK:   %[[OkRet:.+]] = call i32 @_ZNSt16coroutine_traitsIJi28promise_on_alloc_failure_tagEE12promise_type17get_return_objectEv(
   // CHECK:   store i32 %[[OkRet]], i32* %[[Gro]]
 
   // CHECK: %[[Tmp1:.*]] = load i32, i32* %[[Gro]]
   // CHECK-NEXT: store i32 %[[Tmp1]], i32* %[[RetVal]]
   // CHECK-NEXT: %[[Gro_CAST:.+]] = bitcast i32* %[[Gro]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* %[[Gro_CAST]]) #2
   // CHECK-NEXT: br label %[[RetBB]]
 
   // CHECK: [[RetBB]]:
   // CHECK:   %[[LoadRet:.+]] = load i32, i32* %[[RetVal]], align 4
   // CHECK:   ret i32 %[[LoadRet]]
   co_return;
 }

clang/test/CodeGenCoroutines/coro-always-inline.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fcoroutines-ts \
 // RUN:   -fexperimental-new-pass-manager -O0 %s -o - | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fcoroutines-ts \
 // RUN:   -fexperimental-new-pass-manager -fno-inline -O0 %s -o - | FileCheck %s
 
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fcoroutines-ts \
 // RUN:   -O0 %s -o - | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fcoroutines-ts \
 // RUN:   -fno-inline -O0 %s -o - | FileCheck %s
 
 namespace std {
-namespace experimental {
 
 struct handle {};
 
 struct awaitable {
   bool await_ready() noexcept { return true; }
   // CHECK-NOT: await_suspend
   inline void __attribute__((__always_inline__)) await_suspend(handle) noexcept {}
   bool await_resume() noexcept { return true; }
struct coroutine_traits {
   struct promise_type {
     awaitable initial_suspend() { return {}; }
     awaitable final_suspend() noexcept { return {}; }
     void return_void() {}
     T get_return_object() { return T(); }
     void unhandled_exception() {}
   };
 };
-} // namespace experimental
 } // namespace std
 
 // CHECK-LABEL: @_Z3foov
 // CHECK-LABEL: entry:
-// CHECK: [[CAST0:%[0-9]+]] = bitcast %"struct.std::experimental::awaitable"* %ref.tmp{{.*}} to i8*
+// CHECK: [[CAST0:%[0-9]+]] = bitcast %"struct.std::awaitable"* %ref.tmp{{.*}} to i8*
 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 1, i8* [[CAST0]])
-// CHECK: [[CAST1:%[0-9]+]] = bitcast %"struct.std::experimental::awaitable"* %ref.tmp{{.*}} to i8*
+// CHECK: [[CAST1:%[0-9]+]] = bitcast %"struct.std::awaitable"* %ref.tmp{{.*}} to i8*
 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 1, i8* [[CAST1]])
 
-// CHECK: [[CAST2:%[0-9]+]] = bitcast %"struct.std::experimental::awaitable"* %ref.tmp{{.*}} to i8*
+// CHECK: [[CAST2:%[0-9]+]] = bitcast %"struct.std::awaitable"* %ref.tmp{{.*}} to i8*
 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 1, i8* [[CAST2]])
-// CHECK: [[CAST3:%[0-9]+]] = bitcast %"struct.std::experimental::awaitable"* %ref.tmp{{.*}} to i8*
+// CHECK: [[CAST3:%[0-9]+]] = bitcast %"struct.std::awaitable"* %ref.tmp{{.*}} to i8*
 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 1, i8* [[CAST3]])
 void foo() { co_return; }

clang/test/CodeGenCoroutines/coro-await-domination.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm %s -o - | FileCheck %s
 #include "Inputs/coroutine.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct coro {
   struct promise_type {
     coro get_return_object();
     suspend_never initial_suspend();
     suspend_never final_suspend() noexcept;
     void return_void();
     static void unhandled_exception();

clang/test/CodeGenCoroutines/coro-await-resume-eh.cpp

 // Test the behavior of http://wg21.link/P0664, a proposal to catch any
 // exceptions thrown after the initial suspend point of a coroutine by
 // executing the handler specified by the promise type's 'unhandled_exception'
 // member function.
 //
 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts \
 // RUN:   -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s \
 // RUN:   -fexceptions -fcxx-exceptions -disable-llvm-passes \
 // RUN:   | FileCheck %s
 
 #include "Inputs/coroutine.h"
 
-namespace coro = std::experimental::coroutines_v1;
-
 struct throwing_awaitable {
   bool await_ready() { return true; }
-  void await_suspend(coro::coroutine_handle<>) {}
+  void await_suspend(std::coroutine_handle<>) {}
   void await_resume() { throw 42; }
 };
 
 struct throwing_task {
   struct promise_type {
     auto get_return_object() { return throwing_task{}; }
     auto initial_suspend() { return throwing_awaitable{}; }
-    auto final_suspend() noexcept { return coro::suspend_never{}; }
+    auto final_suspend() noexcept { return std::suspend_never{}; }
     void return_void() {}
     void unhandled_exception() {}
   };
 };
 
 // CHECK-LABEL: define{{.*}} void @_Z1fv()
 throwing_task f() {
   // A variable RESUMETHREW is used to keep track of whether the body
throwing_task f() {
 
   // CHECK: [[COROFINAL]]:
   // CHECK: call void @_ZN13throwing_task12promise_type13final_suspendEv
   co_return;
 }
 
 struct noexcept_awaitable {
   bool await_ready() { return true; }
-  void await_suspend(coro::coroutine_handle<>) {}
+  void await_suspend(std::coroutine_handle<>) {}
   void await_resume() noexcept {}
 };
 
 struct noexcept_task {
   struct promise_type {
     auto get_return_object() { return noexcept_task{}; }
     auto initial_suspend() { return noexcept_awaitable{}; }
-    auto final_suspend() noexcept { return coro::suspend_never{}; }
+    auto final_suspend() noexcept { return std::suspend_never{}; }
     void return_void() {}
     void unhandled_exception() {}
   };
 };
 
 // CHECK-LABEL: define{{.*}} void @_Z1gv()
 noexcept_task g() {
   // If the await_resume function is marked as noexcept, none of the additional
   // conditions that are present in f() above are added to the IR.
   // This means that no i1 are stored before or after calling await_resume:
   // CHECK: init.ready:
   // CHECK-NEXT: call void @_ZN18noexcept_awaitable12await_resumeEv
   // CHECK-NOT: store i1 false, i1*
   co_return;
 }

clang/test/CodeGenCoroutines/coro-await.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 \
 // RUN:   -emit-llvm %s -o - -disable-llvm-passes -Wno-coroutine -Wno-unused | FileCheck %s
 
 namespace std {
-namespace experimental {
 template <typename... T>
 struct coroutine_traits;
 
 template <typename Promise = void> struct coroutine_handle;
 
 template <>
 struct coroutine_handle<void> {
   void *ptr;
   static coroutine_handle from_address(void *);
   void *address();
 };
 
 template <typename Promise>
 struct coroutine_handle : coroutine_handle<> {
   static coroutine_handle from_address(void *) noexcept;
 };
 
 }
-}
 
 struct init_susp {
   bool await_ready();
-  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 struct final_susp {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
 struct suspend_always {
   int stuff;
   bool await_ready();
-  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 
-template<>
-struct std::experimental::coroutine_traits<void> {
+template <>
+struct std::coroutine_traits<void> {
   struct promise_type {
     void get_return_object();
     init_susp initial_suspend();
     final_susp final_suspend() noexcept;
     void return_void();
   };
 };
 
 // CHECK-LABEL: f0(
 extern "C" void f0() {
   // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
 
   // See if initial_suspend was issued:
   // ----------------------------------
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type15initial_suspendEv(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_type15initial_suspendEv(
   // CHECK-NEXT: call zeroext i1 @_ZN9init_susp11await_readyEv(%struct.init_susp*
   // CHECK: %[[INITSP_ID:.+]] = call token @llvm.coro.save(
   // CHECK: call i8 @llvm.coro.suspend(token %[[INITSP_ID]], i1 false)
 
   co_await suspend_always{};
   // See if we need to suspend:
   // --------------------------
   // CHECK: %[[READY:.+]] = call zeroext i1 @_ZN14suspend_always11await_readyEv(%struct.suspend_always* {{[^,]*}} %[[AWAITABLE:.+]])
   // CHECK: br i1 %[[READY]], label %[[READY_BB:.+]], label %[[SUSPEND_BB:.+]]
 
   // If we are suspending:
   // ---------------------
   // CHECK: [[SUSPEND_BB]]:
   // CHECK: %[[SUSPEND_ID:.+]] = call token @llvm.coro.save(
   // ---------------------------
   // Build the coroutine handle and pass it to await_suspend
   // ---------------------------
-  // CHECK: call i8* @_ZNSt12experimental16coroutine_handleINS_16coroutine_traitsIJvEE12promise_typeEE12from_addressEPv(i8* %[[FRAME]])
+  // CHECK: call i8* @_ZNSt16coroutine_handleINSt16coroutine_traitsIJvEE12promise_typeEE12from_addressEPv(i8* %[[FRAME]])
   //   ... many lines of code to coerce coroutine_handle into an i8* scalar
   // CHECK: %[[CH:.+]] = load i8*, i8** %{{.+}}
-  // CHECK: call void @_ZN14suspend_always13await_suspendENSt12experimental16coroutine_handleIvEE(%struct.suspend_always* {{[^,]*}} %[[AWAITABLE]], i8* %[[CH]])
+  // CHECK: call void @_ZN14suspend_always13await_suspendESt16coroutine_handleIvE(%struct.suspend_always* {{[^,]*}} %[[AWAITABLE]], i8* %[[CH]])
   // -------------------------
   // Generate a suspend point:
   // -------------------------
   // CHECK: %[[OUTCOME:.+]] = call i8 @llvm.coro.suspend(token %[[SUSPEND_ID]], i1 false)
   // CHECK: switch i8 %[[OUTCOME]], label %[[RET_BB:.+]] [
   // CHECK:   i8 0, label %[[READY_BB]]
   // CHECK:   i8 1, label %[[CLEANUP_BB:.+]]
   // CHECK: ]
 
   // Cleanup code goes here:
   // -----------------------
   // CHECK: [[CLEANUP_BB]]:
 
   // When coroutine is resumed, call await_resume
   // --------------------------
   // CHECK: [[READY_BB]]:
   // CHECK:  call void @_ZN14suspend_always12await_resumeEv(%struct.suspend_always* {{[^,]*}} %[[AWAITABLE]])
 
   // See if final_suspend was issued:
   // ----------------------------------
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type13final_suspendEv(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_type13final_suspendEv(
   // CHECK-NEXT: call zeroext i1 @_ZN10final_susp11await_readyEv(%struct.final_susp*
   // CHECK: %[[FINALSP_ID:.+]] = call token @llvm.coro.save(
   // CHECK: call i8 @llvm.coro.suspend(token %[[FINALSP_ID]], i1 true)
 }
 
 struct suspend_maybe {
   float stuff;
   ~suspend_maybe();
   bool await_ready();
-  bool await_suspend(std::experimental::coroutine_handle<>);
+  bool await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 
-
-template<>
-struct std::experimental::coroutine_traits<void,int> {
+template <>
+struct std::coroutine_traits<void, int> {
   struct promise_type {
     void get_return_object();
     init_susp initial_suspend();
     final_susp final_suspend() noexcept;
     void return_void();
     suspend_maybe yield_value(int);
   };
 };
 
 // CHECK-LABEL: f1(
 extern "C" void f1(int) {
-  // CHECK: %[[PROMISE:.+]] = alloca %"struct.std::experimental::coroutine_traits<void, int>::promise_type"
+  // CHECK: %[[PROMISE:.+]] = alloca %"struct.std::coroutine_traits<void, int>::promise_type"
   // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
   co_yield 42;
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJviEE12promise_type11yield_valueEi(%struct.suspend_maybe* sret(%struct.suspend_maybe) align 4 %[[AWAITER:.+]], %"struct.std::experimental::coroutine_traits<void, int>::promise_type"* {{[^,]*}} %[[PROMISE]], i32 42)
+  // CHECK: call void @_ZNSt16coroutine_traitsIJviEE12promise_type11yield_valueEi(%struct.suspend_maybe* sret(%struct.suspend_maybe) align 4 %[[AWAITER:.+]], %"struct.std::coroutine_traits<void, int>::promise_type"* {{[^,]*}} %[[PROMISE]], i32 42)
 
   // See if we need to suspend:
   // --------------------------
   // CHECK: %[[READY:.+]] = call zeroext i1 @_ZN13suspend_maybe11await_readyEv(%struct.suspend_maybe* {{[^,]*}} %[[AWAITABLE]])
   // CHECK: br i1 %[[READY]], label %[[READY_BB:.+]], label %[[SUSPEND_BB:.+]]
 
   // If we are suspending:
   // ---------------------
   // CHECK: [[SUSPEND_BB]]:
   // CHECK: %[[SUSPEND_ID:.+]] = call token @llvm.coro.save(
   // ---------------------------
   // Build the coroutine handle and pass it to await_suspend
   // ---------------------------
-  // CHECK: call i8* @_ZNSt12experimental16coroutine_handleINS_16coroutine_traitsIJviEE12promise_typeEE12from_addressEPv(i8* %[[FRAME]])
+  // CHECK: call i8* @_ZNSt16coroutine_handleINSt16coroutine_traitsIJviEE12promise_typeEE12from_addressEPv(i8* %[[FRAME]])
   //   ... many lines of code to coerce coroutine_handle into an i8* scalar
   // CHECK: %[[CH:.+]] = load i8*, i8** %{{.+}}
-  // CHECK: %[[YES:.+]] = call zeroext i1 @_ZN13suspend_maybe13await_suspendENSt12experimental16coroutine_handleIvEE(%struct.suspend_maybe* {{[^,]*}} %[[AWAITABLE]], i8* %[[CH]])
+  // CHECK: %[[YES:.+]] = call zeroext i1 @_ZN13suspend_maybe13await_suspendESt16coroutine_handleIvE(%struct.suspend_maybe* {{[^,]*}} %[[AWAITABLE]], i8* %[[CH]])
   // -------------------------------------------
   // See if await_suspend decided not to suspend
   // -------------------------------------------
   // CHECK: br i1 %[[YES]], label %[[SUSPEND_PLEASE:.+]], label %[[READY_BB]]
 
   // CHECK: [[SUSPEND_PLEASE]]:
   // CHECK:    call i8 @llvm.coro.suspend(token %[[SUSPEND_ID]], i1 false)
 

 }
 
 // CHECK-LABEL: EndlessLoop(
 extern "C" void EndlessLoop() {
   // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
 
   // See if initial_suspend was issued:
   // ----------------------------------
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type15initial_suspendEv(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_type15initial_suspendEv(
   // CHECK-NEXT: call zeroext i1 @_ZN9init_susp11await_readyEv(%struct.init_susp*
 
   for (;;)
     co_await suspend_always{};
 
   // Verify that final_suspend was NOT issued:
   // ----------------------------------
-  // CHECK-NOT: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type13final_suspendEv(
+  // CHECK-NOT: call void @_ZNSt16coroutine_traitsIJvEE12promise_type13final_suspendEv(
   // CHECK-NOT: call zeroext i1 @_ZN10final_susp11await_readyEv(%struct.final_susp*
 }
 
 // Verifies that we don't crash when awaiting on an lvalue.
 // CHECK-LABEL: @_Z11AwaitLValuev(
 void AwaitLValue() {
   suspend_always lval;
   co_await lval;
 }
 
 struct RefTag { };
 
 struct AwaitResumeReturnsLValue {
   bool await_ready();
-  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_suspend(std::coroutine_handle<>);
   RefTag& await_resume();
 };
 
-
-template<>
-struct std::experimental::coroutine_traits<void,double> {
+template <>
+struct std::coroutine_traits<void, double> {
   struct promise_type {
     void get_return_object();
     init_susp initial_suspend();
     final_susp final_suspend() noexcept;
     void return_void();
     AwaitResumeReturnsLValue yield_value(int);
   };
 };
void AwaitReturnsLValue(double) {
   // CHECK-NEXT: store %struct.RefTag* %[[RES3]], %struct.RefTag** %[[TMP_EXPRCLEANUP2]],
   // CHECK: %[[LOAD_TMP2:.+]] = load %struct.RefTag*, %struct.RefTag** %[[TMP_EXPRCLEANUP2]],
   // CHECK: store %struct.RefTag* %[[LOAD_TMP2]], %struct.RefTag** %[[ZVAR]],
   RefTag& z = co_yield 42;
 }
 
 struct TailCallAwait {
   bool await_ready();
-  std::experimental::coroutine_handle<> await_suspend(std::experimental::coroutine_handle<>);
+  std::coroutine_handle<> await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 
 // CHECK-LABEL: @TestTailcall(
 extern "C" void TestTailcall() {
   co_await TailCallAwait{};
 
-  // CHECK: %[[RESULT:.+]] = call i8* @_ZN13TailCallAwait13await_suspendENSt12experimental16coroutine_handleIvEE(%struct.TailCallAwait*
-  // CHECK: %[[COERCE:.+]] = getelementptr inbounds %"struct.std::experimental::coroutine_handle", %"struct.std::experimental::coroutine_handle"* %[[TMP:.+]], i32 0, i32 0
+  // CHECK: %[[RESULT:.+]] = call i8* @_ZN13TailCallAwait13await_suspendESt16coroutine_handleIvE(%struct.TailCallAwait*
+  // CHECK: %[[COERCE:.+]] = getelementptr inbounds %"struct.std::coroutine_handle", %"struct.std::coroutine_handle"* %[[TMP:.+]], i32 0, i32 0
   // CHECK: store i8* %[[RESULT]], i8** %[[COERCE]]
-  // CHECK: %[[ADDR:.+]] = call i8* @_ZNSt12experimental16coroutine_handleIvE7addressEv(%"struct.std::experimental::coroutine_handle"* {{[^,]*}} %[[TMP]])
+  // CHECK: %[[ADDR:.+]] = call i8* @_ZNSt16coroutine_handleIvE7addressEv(%"struct.std::coroutine_handle"* {{[^,]*}} %[[TMP]])
   // CHECK: call void @llvm.coro.resume(i8* %[[ADDR]])
 }

clang/test/CodeGenCoroutines/coro-cleanup.cpp

 // Verify that coroutine promise and allocated memory are freed up on exception.
 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck %s
 
-namespace std::experimental {
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
-template <> struct std::experimental::coroutine_traits<void> {
+template <> struct std::coroutine_traits<void> {
   struct promise_type {
     void get_return_object() noexcept;
     suspend_always initial_suspend() noexcept;
     suspend_always final_suspend() noexcept;
     void return_void() noexcept;
     promise_type();
     ~promise_type();
     void unhandled_exception() noexcept;
   };
 };
 
 struct Cleanup { ~Cleanup(); };
 void may_throw();
 
 // CHECK-LABEL: define{{.*}} void @_Z1fv(
 void f() {
   // CHECK: call noalias nonnull i8* @_Znwm(i64
 
   // If promise constructor throws, check that we free the memory.
 
-  // CHECK: invoke void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_typeC1Ev(
+  // CHECK: invoke void @_ZNSt16coroutine_traitsIJvEE12promise_typeC1Ev(
   // CHECK-NEXT: to label %{{.+}} unwind label %[[DeallocPad:.+]]
 
   // CHECK: [[DeallocPad]]:
   // CHECK-NEXT: landingpad
   // CHECK-NEXT:   cleanup
   // CHECK: br label %[[Dealloc:.+]]
 
   Cleanup cleanup;
   may_throw();
 
   // if may_throw throws, check that we destroy the promise and free the memory.
 
   // CHECK: invoke void @_Z9may_throwv(
   // CHECK-NEXT: to label %{{.+}} unwind label %[[CatchPad:.+]]
 
   // CHECK: [[CatchPad]]:
   // CHECK-NEXT:  landingpad
   // CHECK-NEXT:       catch i8* null
   // CHECK:  call void @_ZN7CleanupD1Ev(
   // CHECK:  br label %[[Catch:.+]]
 
   // CHECK: [[Catch]]:
   // CHECK:    call i8* @__cxa_begin_catch(
-  // CHECK:    call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type19unhandled_exceptionEv(
+  // CHECK:    call void @_ZNSt16coroutine_traitsIJvEE12promise_type19unhandled_exceptionEv(
   // CHECK:    invoke void @__cxa_end_catch()
   // CHECK-NEXT:    to label %[[Cont:.+]] unwind
 
   // CHECK: [[Cont]]:
   // CHECK-NEXT: br label %[[Cont2:.+]]
   // CHECK: [[Cont2]]:
   // CHECK-NEXT: br label %[[Cleanup:.+]]
 
   // CHECK: [[Cleanup]]:
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_typeD1Ev(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_typeD1Ev(
   // CHECK: %[[Mem0:.+]] = call i8* @llvm.coro.free(
   // CHECK: call void @_ZdlPv(i8* %[[Mem0]]
 
   // CHECK: [[Dealloc]]:
   // CHECK:   %[[Mem:.+]] = call i8* @llvm.coro.free(
   // CHECK:   call void @_ZdlPv(i8* %[[Mem]])
 
   co_return;
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z1gv(
 void g() {
   for (;;)
     co_await suspend_always{};
   // Since this is the endless loop there should be no fallthrough handler (call to 'return_void').
-  // CHECK-NOT: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type11return_voidEv
+  // CHECK-NOT: call void @_ZNSt16coroutine_traitsIJvEE12promise_type11return_voidEv
 }

clang/test/CodeGenCoroutines/coro-dest-slot.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
 
 #include "Inputs/coroutine.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct coro {
   struct promise_type {
     coro get_return_object();
     suspend_always initial_suspend();
     suspend_never final_suspend() noexcept;
     void return_void();
     static void unhandled_exception();

 // CHECK: %[[CLEANUP_DEST0:.+]] = phi i32 [ 0, %[[INIT_READY]] ], [ 2, %[[INIT_CLEANUP]] ]
 
 // CHECK: %[[FINAL_SUSPEND:.+]] = call i8 @llvm.coro.suspend(
 // CHECK-NEXT: switch i8 %{{.*}}, label %coro.ret [
 // CHECK-NEXT:   i8 0, label %[[FINAL_READY:.+]]
 // CHECK-NEXT:   i8 1, label %[[FINAL_CLEANUP:.+]]
 // CHECK-NEXT: ]
 
-// CHECK: call void @_ZNSt12experimental13coroutines_v113suspend_never12await_resumeEv(
+// CHECK: call void @_ZNSt13suspend_never12await_resumeEv(
 // CHECK: %[[CLEANUP_DEST1:.+]] = phi i32 [ 0, %[[FINAL_READY]] ], [ 2, %[[FINAL_CLEANUP]] ]
 // CHECK: %[[CLEANUP_DEST2:.+]] = phi i32 [ %[[CLEANUP_DEST0]], %{{.+}} ], [ %[[CLEANUP_DEST1]], %{{.+}} ], [ 0, %{{.+}} ]
 // CHECK: call i8* @llvm.coro.free(
 // CHECK: switch i32 %[[CLEANUP_DEST2]], label %{{.+}} [
 // CHECK-NEXT: i32 0
 // CHECK-NEXT: i32 2
 // CHECK-NEXT: ]

clang/test/CodeGenCoroutines/coro-dwarf.cpp

 // RUN: %clang_cc1 -disable-llvm-optzns -std=c++2a -fcoroutines-ts \
 // RUN:            -triple=x86_64 -dwarf-version=4 -debug-info-kind=limited \
 // RUN:            -emit-llvm -o - %s | \
 // RUN:            FileCheck %s --implicit-check-not=DILocalVariable
 
-namespace std::experimental {
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-} // namespace std::experimental
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
-template <typename... Args> struct std::experimental::coroutine_traits<void, Args...> {
+template <typename... Args> struct std::coroutine_traits<void, Args...> {
   struct promise_type {
     void get_return_object() noexcept;
     suspend_always initial_suspend() noexcept;
     suspend_always final_suspend() noexcept;
     void return_void() noexcept;
     promise_type();
     ~promise_type() noexcept;
     void unhandled_exception() noexcept;

clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp

 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -triple=x86_64-pc-windows-msvc18.0.0 -emit-llvm %s -o - -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck %s
 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck --check-prefix=CHECK-LPAD %s
 
-namespace std::experimental {
+namespace std {
 template <typename R, typename... T> struct coroutine_traits {
   using promise_type = typename R::promise_type;
 };
 
 template <class Promise = void> struct coroutine_handle;
 
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
 template <class Promise> struct coroutine_handle: coroutine_handle<void> {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
 struct coro_t {
   struct promise_type {
     coro_t get_return_object() noexcept;
     suspend_always initial_suspend() noexcept;
     suspend_always final_suspend() noexcept;

clang/test/CodeGenCoroutines/coro-gro-nrvo.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
 
 #include "Inputs/coroutine.h"
 
-using namespace std::experimental;
+using namespace std;
 
 namespace std {
 
 struct nothrow_t {};
 constexpr nothrow_t nothrow = {};
 
 } // end namespace std
 

clang/test/CodeGenCoroutines/coro-gro.cpp

 // Verifies lifetime of __gro local variable
 // Verify that coroutine promise and allocated memory are freed up on exception.
 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -disable-llvm-passes | FileCheck %s
 
-namespace std::experimental {
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
 struct GroType {
   ~GroType();
   operator int() noexcept;
 };
 
-template <> struct std::experimental::coroutine_traits<int> {
+template <> struct std::coroutine_traits<int> {
   struct promise_type {
     GroType get_return_object() noexcept;
     suspend_always initial_suspend() noexcept;
     suspend_always final_suspend() noexcept;
     void return_void() noexcept;
     promise_type();
     ~promise_type();
     void unhandled_exception() noexcept;
   };
 };
 
 struct Cleanup { ~Cleanup(); };
 void doSomething() noexcept;
 
 // CHECK: define{{.*}} i32 @_Z1fv(
 int f() {
   // CHECK: %[[RetVal:.+]] = alloca i32
   // CHECK: %[[GroActive:.+]] = alloca i1
 
   // CHECK: %[[Size:.+]] = call i64 @llvm.coro.size.i64()
   // CHECK: call noalias nonnull i8* @_Znwm(i64 %[[Size]])
   // CHECK: store i1 false, i1* %[[GroActive]]
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJiEE12promise_typeC1Ev(
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJiEE12promise_type17get_return_objectEv(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJiEE12promise_typeC1Ev(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJiEE12promise_type17get_return_objectEv(
   // CHECK: store i1 true, i1* %[[GroActive]]
 
   Cleanup cleanup;
   doSomething();
   co_return;
 
   // CHECK: call void @_Z11doSomethingv(
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJiEE12promise_type11return_voidEv(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJiEE12promise_type11return_voidEv(
   // CHECK: call void @_ZN7CleanupD1Ev(
 
   // Destroy promise and free the memory.
 
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJiEE12promise_typeD1Ev(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJiEE12promise_typeD1Ev(
   // CHECK: %[[Mem:.+]] = call i8* @llvm.coro.free(
   // CHECK: call void @_ZdlPv(i8* %[[Mem]])
 
   // Initialize retval from Gro and destroy Gro
 
   // CHECK: %[[Conv:.+]] = call i32 @_ZN7GroTypecviEv(
   // CHECK: store i32 %[[Conv]], i32* %[[RetVal]]
   // CHECK: %[[IsActive:.+]] = load i1, i1* %[[GroActive]]

clang/test/CodeGenCoroutines/coro-lambda.cpp

 // Verify that we synthesized the coroutine for a lambda inside of a function template.
 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck %s
 
-namespace std::experimental {
+namespace std {
 template <typename R, typename... T> struct coroutine_traits {
   using promise_type = typename R::promise_type;
 };
 
 template <class Promise = void> struct coroutine_handle;
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
 template <class Promise> struct coroutine_handle : coroutine_handle<void> {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
 struct Task {
   struct promise_type {
     Task get_return_object();
     void return_void() {}
     suspend_always initial_suspend() noexcept;

clang/test/CodeGenCoroutines/coro-newpm-pipeline.cpp

 // CHECK-ALL: Running pass:{{.*}}CoroEarlyPass
 //
 // CHECK-ALL: Running pass: CoroSplitPass on (_Z3foov)
 // CHECK-OPT: Running pass:{{.*}}CoroElidePass{{.*}} on {{.*}}_Z3foov{{.*}}
 //
 // CHECK-ALL: Running pass:{{.*}}CoroCleanupPass
 
 namespace std {
-namespace experimental {
 
 struct handle {};
 
 struct awaitable {
   bool await_ready() noexcept { return false; }
   void await_suspend(handle) noexcept {}
   bool await_resume() noexcept { return true; }
 };
 
 template <typename T> struct coroutine_handle {
   static handle from_address(void *address) noexcept { return {}; }
 };
 
 template <typename T = void> struct coroutine_traits {
   struct promise_type {
     awaitable initial_suspend() { return {}; }
     awaitable final_suspend() noexcept { return {}; }
     void return_void() {}
     T get_return_object() { return T(); }
     void unhandled_exception() {}
   };
 };
-} // namespace experimental
 } // namespace std
 
 void foo() { co_return; }

clang/test/CodeGenCoroutines/coro-params.cpp

 // Verifies that parameters are copied with move constructors
 // Verifies that parameter copies are destroyed
 // Vefifies that parameter copies are used in the body of the coroutine
 // Verifies that parameter copies are used to construct the promise type, if that type has a matching constructor
 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -disable-llvm-passes -fexceptions | FileCheck %s
 
-namespace std::experimental {
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
-template <typename... Args> struct std::experimental::coroutine_traits<void, Args...> {
+template <typename... Args> struct std::coroutine_traits<void, Args...> {
   struct promise_type {
     void get_return_object() noexcept;
     suspend_always initial_suspend() noexcept;
     suspend_always final_suspend() noexcept;
     void return_void() noexcept;
     promise_type();
     ~promise_type() noexcept;
     void unhandled_exception() noexcept;
void f(int val, MoveOnly moParam, MoveAndCopy mcParam) {
   // CHECK: %[[McCopy:.+]] = alloca %struct.MoveAndCopy
   // CHECK: store i32 %val, i32* %[[ValAddr:.+]]
 
   // CHECK: call i8* @llvm.coro.begin(
   // CHECK: call void @_ZN8MoveOnlyC1EOS_(%struct.MoveOnly* {{[^,]*}} %[[MoCopy]], %struct.MoveOnly* nonnull align 4 dereferenceable(4) %[[MoParam]])
   // CHECK-NEXT: bitcast %struct.MoveAndCopy* %[[McCopy]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(
   // CHECK-NEXT: call void @_ZN11MoveAndCopyC1EOS_(%struct.MoveAndCopy* {{[^,]*}} %[[McCopy]], %struct.MoveAndCopy* nonnull align 4 dereferenceable(4) %[[McParam]]) #
-  // CHECK-NEXT: bitcast %"struct.std::experimental::coroutine_traits<void, int, MoveOnly, MoveAndCopy>::promise_type"* %__promise to i8*
+  // CHECK-NEXT: bitcast %"struct.std::coroutine_traits<void, int, MoveOnly, MoveAndCopy>::promise_type"* %__promise to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(
-  // CHECK-NEXT: invoke void @_ZNSt12experimental16coroutine_traitsIJvi8MoveOnly11MoveAndCopyEE12promise_typeC1Ev(
+  // CHECK-NEXT: invoke void @_ZNSt16coroutine_traitsIJvi8MoveOnly11MoveAndCopyEE12promise_typeC1Ev(
 
   // CHECK: call void @_ZN14suspend_always12await_resumeEv(
   // CHECK: %[[IntParam:.+]] = load i32, i32* %{{.*}}
   // CHECK: %[[MoGep:.+]] = getelementptr inbounds %struct.MoveOnly, %struct.MoveOnly* %[[MoCopy]], i32 0, i32 0
   // CHECK: %[[MoVal:.+]] = load i32, i32* %[[MoGep]]
   // CHECK: %[[McGep:.+]] =  getelementptr inbounds %struct.MoveAndCopy, %struct.MoveAndCopy* %[[McCopy]], i32 0, i32 0
   // CHECK: %[[McVal:.+]] = load i32, i32* %[[McGep]]
   // CHECK: call void @_Z7consumeiii(i32 %[[IntParam]], i32 %[[MoVal]], i32 %[[McVal]])
 
   consume(val, moParam.val, mcParam.val);
   co_return;
 
   // Skip to final suspend:
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvi8MoveOnly11MoveAndCopyEE12promise_type13final_suspendEv(
+  // CHECK: call void @_ZNSt16coroutine_traitsIJvi8MoveOnly11MoveAndCopyEE12promise_type13final_suspendEv(
   // CHECK: call void @_ZN14suspend_always12await_resumeEv(
 
   // Destroy promise, then parameter copies:
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvi8MoveOnly11MoveAndCopyEE12promise_typeD1Ev(%"struct.std::experimental::coroutine_traits<void, int, MoveOnly, MoveAndCopy>::promise_type"* {{[^,]*}} %__promise)
-  // CHECK-NEXT: bitcast %"struct.std::experimental::coroutine_traits<void, int, MoveOnly, MoveAndCopy>::promise_type"* %__promise to i8*
+  // CHECK: call void @_ZNSt16coroutine_traitsIJvi8MoveOnly11MoveAndCopyEE12promise_typeD1Ev(%"struct.std::coroutine_traits<void, int, MoveOnly, MoveAndCopy>::promise_type"* {{[^,]*}} %__promise)
+  // CHECK-NEXT: bitcast %"struct.std::coroutine_traits<void, int, MoveOnly, MoveAndCopy>::promise_type"* %__promise to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(
   // CHECK-NEXT: call void @_ZN11MoveAndCopyD1Ev(%struct.MoveAndCopy* {{[^,]*}} %[[McCopy]])
   // CHECK-NEXT: bitcast %struct.MoveAndCopy* %[[McCopy]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(
   // CHECK-NEXT: call void @_ZN8MoveOnlyD1Ev(%struct.MoveOnly* {{[^,]*}} %[[MoCopy]]
   // CHECK-NEXT: bitcast %struct.MoveOnly* %[[MoCopy]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(
   // CHECK-NEXT: bitcast i32* %{{.+}} to i8*
void dependent_params(T x, U, U y) {
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(
   // CHECK-NEXT: call void @_ZN1AC1EOS_(%struct.A* {{[^,]*}} %[[x_copy]], %struct.A* nonnull align 4 dereferenceable(512) %x)
   // CHECK-NEXT: bitcast %struct.B* %[[unnamed_copy]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(
   // CHECK-NEXT: call void @_ZN1BC1EOS_(%struct.B* {{[^,]*}} %[[unnamed_copy]], %struct.B* nonnull align 4 dereferenceable(512) %0)
   // CHECK-NEXT: bitcast %struct.B* %[[y_copy]] to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(
   // CHECK-NEXT: call void @_ZN1BC1EOS_(%struct.B* {{[^,]*}} %[[y_copy]], %struct.B* nonnull align 4 dereferenceable(512) %y)
-  // CHECK-NEXT: bitcast %"struct.std::experimental::coroutine_traits<void, A, B, B>::promise_type"* %__promise to i8*
+  // CHECK-NEXT: bitcast %"struct.std::coroutine_traits<void, A, B, B>::promise_type"* %__promise to i8*
   // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(
-  // CHECK-NEXT: invoke void @_ZNSt12experimental16coroutine_traitsIJv1A1BS2_EE12promise_typeC1Ev(
+  // CHECK-NEXT: invoke void @_ZNSt16coroutine_traitsIJv1A1BS1_EE12promise_typeC1Ev(
 
   co_return;
 }
 
 struct A {
   int WontFitIntoRegisterForSure[128];
   A();
   A(A&&) noexcept;

 }
 
 // Test that, when the promise type has a constructor whose signature matches
 // that of the coroutine function, that constructor is used. This is an
 // experimental feature that will be proposed for the Coroutines TS.
 
 struct promise_matching_constructor {};
 
-template<>
-struct std::experimental::coroutine_traits<void, promise_matching_constructor, int, float, double> {
+template <>
+struct std::coroutine_traits<void, promise_matching_constructor, int, float, double> {
   struct promise_type {
     promise_type(promise_matching_constructor, int, float, double) {}
     promise_type() = delete;
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception() {}
   };
 };
 
 // CHECK-LABEL: void @_Z38coroutine_matching_promise_constructor28promise_matching_constructorifd(i32 %0, float %1, double %2)
 void coroutine_matching_promise_constructor(promise_matching_constructor, int, float, double) {
   // CHECK: %[[INT:.+]] = load i32, i32* %5, align 4
   // CHECK: %[[FLOAT:.+]] = load float, float* %6, align 4
   // CHECK: %[[DOUBLE:.+]] = load double, double* %7, align 8
-  // CHECK: invoke void @_ZNSt12experimental16coroutine_traitsIJv28promise_matching_constructorifdEE12promise_typeC1ES1_ifd(%"struct.std::experimental::coroutine_traits<void, promise_matching_constructor, int, float, double>::promise_type"* {{[^,]*}} %__promise, i32 %[[INT]], float %[[FLOAT]], double %[[DOUBLE]])
+  // CHECK: invoke void @_ZNSt16coroutine_traitsIJv28promise_matching_constructorifdEE12promise_typeC1ES0_ifd(%"struct.std::coroutine_traits<void, promise_matching_constructor, int, float, double>::promise_type"* {{[^,]*}} %__promise, i32 %[[INT]], float %[[FLOAT]], double %[[DOUBLE]])
   co_return;
 }
 
 struct some_class;
 
 struct method {};
 
-template <typename... Args> struct std::experimental::coroutine_traits<method, Args...> {
+template <typename... Args> struct std::coroutine_traits<method, Args...> {
   struct promise_type {
     promise_type(some_class&, float);
     method get_return_object();
     suspend_always initial_suspend();
     suspend_always final_suspend() noexcept;
     void return_void();
     void unhandled_exception();
   };
 };
 
 struct some_class {
   method good_coroutine_calls_custom_constructor(float);
 };
 
 // CHECK-LABEL: define{{.*}} void @_ZN10some_class39good_coroutine_calls_custom_constructorEf(%struct.some_class*
 method some_class::good_coroutine_calls_custom_constructor(float) {
-  // CHECK: invoke void @_ZNSt12experimental16coroutine_traitsIJ6methodR10some_classfEE12promise_typeC1ES3_f(%"struct.std::experimental::coroutine_traits<method, some_class &, float>::promise_type"* {{[^,]*}} %__promise, %struct.some_class* nonnull align 1 dereferenceable(1) %{{.+}}, float
+  // CHECK: invoke void @_ZNSt16coroutine_traitsIJ6methodR10some_classfEE12promise_typeC1ES2_f(%"struct.std::coroutine_traits<method, some_class &, float>::promise_type"* {{[^,]*}} %__promise, %struct.some_class* nonnull align 1 dereferenceable(1) %{{.+}}, float
   co_return;
 }

clang/test/CodeGenCoroutines/coro-promise-dtor.cpp

 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -triple=x86_64-pc-windows-msvc18.0.0 -emit-llvm -o - %s -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck %s
 // -triple=x86_64-unknown-linux-gnu
 
 #include "Inputs/coroutine.h"
 
-namespace coro = std::experimental::coroutines_v1;
-
 struct coro_t {
   void* p;
   ~coro_t();
   struct promise_type {
     coro_t get_return_object();
-    coro::suspend_never initial_suspend();
-    coro::suspend_never final_suspend() noexcept;
+    std::suspend_never initial_suspend();
+    std::suspend_never final_suspend() noexcept;
     void return_void();
     promise_type();
     ~promise_type();
     void unhandled_exception();
   };
 };
 
 struct Cleanup { ~Cleanup(); };

clang/test/CodeGenCoroutines/coro-ret-void.cpp

 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
 
 #include "Inputs/coroutine.h"
 
-namespace coro = std::experimental::coroutines_v1;
-
 struct coro1 {
   struct promise_type {
     coro1 get_return_object();
-    coro::suspend_never initial_suspend();
-    coro::suspend_never final_suspend() noexcept;
+    std::suspend_never initial_suspend();
+    std::suspend_never final_suspend() noexcept;
     void return_void();
   };
 };
 
 coro1 f() {
-  co_await coro::suspend_never{};
+  co_await std::suspend_never{};
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z1fv(
-// CHECK: call void @_ZNSt12experimental13coroutines_v113suspend_never12await_resumeEv(%"struct.std::experimental::coroutines_v1::suspend_never"*
+// CHECK: call void @_ZNSt13suspend_never12await_resumeEv(%"struct.std::suspend_never"*
 // CHECK: call void @_ZN5coro112promise_type11return_voidEv(%"struct.coro1::promise_type"* {{[^,]*}} %__promise)
 
 struct A {
   A();
   ~A();
 };
 
 coro1 f2() {
   co_return (void) A{};
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z2f2v(
 // CHECK: call void @_ZN1AC1Ev(%struct.A* {{[^,]*}} %[[AVar:.*]])
 // CHECK-NEXT: call void @_ZN1AD1Ev(%struct.A* {{[^,]*}} %[[AVar]])
 // CHECK-NEXT: call void @_ZN5coro112promise_type11return_voidEv(%"struct.coro1::promise_type"*
 
 struct coro2 {
   struct promise_type {
     coro2 get_return_object();
-    coro::suspend_never initial_suspend();
-    coro::suspend_never final_suspend() noexcept;
+    std::suspend_never initial_suspend();
+    std::suspend_never final_suspend() noexcept;
     void return_value(int);
   };
 };
 
 coro2 g() {
   co_return 42;
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z1gv(
-// CHECK: call void @_ZNSt12experimental13coroutines_v113suspend_never12await_resumeEv(%"struct.std::experimental::coroutines_v1::suspend_never"*
+// CHECK: call void @_ZNSt13suspend_never12await_resumeEv(%"struct.std::suspend_never"*
 // CHECK: call void @_ZN5coro212promise_type12return_valueEi(%"struct.coro2::promise_type"* {{[^,]*}} %__promise, i32 42)

clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++1z -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
 
 namespace std {
 template <typename a>
 struct b { b(int, a); };
 template <typename, typename = int>
 struct c {};
-namespace experimental {
 template <typename d>
 struct coroutine_traits : d {};
 template <typename = void>
 struct coroutine_handle;
 template <>
 struct coroutine_handle<> {};
 template <typename>
 struct coroutine_handle : coroutine_handle<> {
   static coroutine_handle from_address(void *) noexcept;
 };
 struct e {
   int await_ready();
   void await_suspend(coroutine_handle<>);
   void await_resume();
 };
-} // namespace experimental
 } // namespace std
 template <typename ag>
 auto ah(ag) { return ag().ah(0); }
 template <typename>
 struct f;
 struct g {
   struct h {
     int await_ready() noexcept;
     template <typename al>
-    void await_suspend(std::experimental::coroutine_handle<al>) noexcept;
+    void await_suspend(std::coroutine_handle<al>) noexcept;
     void await_resume() noexcept;
   };
-  std::experimental::e initial_suspend();
+  std::e initial_suspend();
   h final_suspend() noexcept;
   template <typename ag>
   auto await_transform(ag) { return ah(ag()); }
 };
 struct j : g {
   f<std::b<std::c<int, int>>> get_return_object();
   void return_value(std::b<std::c<int, int>>);
   void unhandled_exception();
 };
 struct k {
-  k(std::experimental::coroutine_handle<>);
+  k(std::coroutine_handle<>);
   int await_ready();
 };
 template <typename am>
 struct f {
   using promise_type = j;
-  std::experimental::coroutine_handle<> ar;
+  std::coroutine_handle<> ar;
   struct l : k {
     using at = k;
-    l(std::experimental::coroutine_handle<> m) : at(m) {}
-    void await_suspend(std::experimental::coroutine_handle<>);
+    l(std::coroutine_handle<> m) : at(m) {}
+    void await_suspend(std::coroutine_handle<>);
   };
   struct n : l {
-    n(std::experimental::coroutine_handle<> m) : l(m) {}
+    n(std::coroutine_handle<> m) : l(m) {}
     am await_resume();
   };
   auto ah(int) { return n(ar); }
 };
 template <typename am, typename av, typename aw>
 auto ax(std::c<am, av>, aw) -> f<std::c<int, aw>>;
 template <typename>
 struct J { static f<std::b<std::c<int, int>>> bo(); };

clang/test/CodeGenCoroutines/coro-return.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++1z -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
 
-namespace std::experimental {
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept { return {}; }
 };
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) { return {}; }
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept {}
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
-template <> struct std::experimental::coroutine_traits<void> {
+template <> struct std::coroutine_traits<void> {
   struct promise_type {
     void get_return_object();
     suspend_always initial_suspend();
     suspend_always final_suspend() noexcept;
     void return_void();
   };
 };
 
 // CHECK-LABEL: f0(
 extern "C" void f0() {
-  // CHECK: %__promise = alloca %"struct.std::experimental::coroutine_traits<void>::promise_type"
+  // CHECK: %__promise = alloca %"struct.std::coroutine_traits<void>::promise_type"
   // CHECK: %call = call noalias nonnull i8* @_Znwm(
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type11return_voidEv(%"struct.std::experimental::coroutine_traits<void>::promise_type"* {{[^,]*}} %__promise)
+  // CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_type11return_voidEv(%"struct.std::coroutine_traits<void>::promise_type"* {{[^,]*}} %__promise)
   // CHECK: call void @_ZdlPv
   co_return;
 }
 
-template<>
-struct std::experimental::coroutine_traits<int> {
+template <>
+struct std::coroutine_traits<int> {
   struct promise_type {
     int get_return_object();
     suspend_always initial_suspend();
     suspend_always final_suspend() noexcept;
     void return_value(int);
   };
 };
 
 // CHECK-LABEL: f1(
 extern "C" int f1() {
-  // CHECK: %__promise = alloca %"struct.std::experimental::coroutine_traits<int>::promise_type"
+  // CHECK: %__promise = alloca %"struct.std::coroutine_traits<int>::promise_type"
   // CHECK: %call = call noalias nonnull i8* @_Znwm(
-  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJiEE12promise_type12return_valueEi(%"struct.std::experimental::coroutine_traits<int>::promise_type"* {{[^,]*}} %__promise, i32 42)
+  // CHECK: call void @_ZNSt16coroutine_traitsIJiEE12promise_type12return_valueEi(%"struct.std::coroutine_traits<int>::promise_type"* {{[^,]*}} %__promise, i32 42)
   // CHECK: call void @_ZdlPv
   co_return 42;
 }

clang/test/CodeGenCoroutines/coro-symmetric-transfer-01.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -O0 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
 // RUN: %clang -fcoroutines-ts -std=c++14 -O0 -emit-llvm -c  %s -o %t -Xclang -disable-llvm-passes && %clang -c %t
 
 #include "Inputs/coroutine.h"
 
-namespace coro = std::experimental::coroutines_v1;
-
 struct detached_task {
   struct promise_type {
     detached_task get_return_object() noexcept {
-      return detached_task{coro::coroutine_handle<promise_type>::from_promise(*this)};
+      return detached_task{std::coroutine_handle<promise_type>::from_promise(*this)};
     }
 
     void return_void() noexcept {}
 
     struct final_awaiter {
       bool await_ready() noexcept { return false; }
-      coro::coroutine_handle<> await_suspend(coro::coroutine_handle<promise_type> h) noexcept {
+      std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h) noexcept {
         h.destroy();
         return {};
       }
       void await_resume() noexcept {}
     };
 
     void unhandled_exception() noexcept {}
 
     final_awaiter final_suspend() noexcept { return {}; }
 
-    coro::suspend_always initial_suspend() noexcept { return {}; }
+    std::suspend_always initial_suspend() noexcept { return {}; }
   };
 
   ~detached_task() {
     if (coro_) {
       coro_.destroy();
       coro_ = {};
     }
   }
 
   void start() && {
     auto tmp = coro_;
     coro_ = {};
     tmp.resume();
   }
 
-  coro::coroutine_handle<promise_type> coro_;
+  std::coroutine_handle<promise_type> coro_;
 };
 
 detached_task foo() {
   co_return;
 }
 
 // check that the lifetime of the coroutine handle used to obtain the address is contained within single basic block, and hence does not live across suspension points.
 // CHECK-LABEL: final.suspend:
 // CHECK:         %{{.+}} = call token @llvm.coro.save(i8* null)
-// CHECK:         %[[HDL_CAST1:.+]] = bitcast %"struct.std::experimental::coroutines_v1::coroutine_handle.0"* %[[HDL:.+]] to i8*
+// CHECK:         %[[HDL_CAST1:.+]] = bitcast %"struct.std::coroutine_handle.0"* %[[HDL:.+]] to i8*
 // CHECK:         call void @llvm.lifetime.start.p0i8(i64 8, i8* %[[HDL_CAST1]])
-// CHECK:         %[[CALL:.+]] = call i8* @_ZN13detached_task12promise_type13final_awaiter13await_suspendENSt12experimental13coroutines_v116coroutine_handleIS0_EE(
-// CHECK:         %[[HDL_CAST2:.+]] = getelementptr inbounds %"struct.std::experimental::coroutines_v1::coroutine_handle.0", %"struct.std::experimental::coroutines_v1::coroutine_handle.0"* %[[HDL]], i32 0, i32 0
+// CHECK:         %[[CALL:.+]] = call i8* @_ZN13detached_task12promise_type13final_awaiter13await_suspendESt16coroutine_handleIS0_E(
+// CHECK:         %[[HDL_CAST2:.+]] = getelementptr inbounds %"struct.std::coroutine_handle.0", %"struct.std::coroutine_handle.0"* %[[HDL]], i32 0, i32 0
 // CHECK:         store i8* %[[CALL]], i8** %[[HDL_CAST2]], align 8
-// CHECK:         %[[HDL_TRANSFER:.+]] = call i8* @_ZNKSt12experimental13coroutines_v116coroutine_handleIvE7addressEv(%"struct.std::experimental::coroutines_v1::coroutine_handle.0"* nonnull align 8 dereferenceable(8) %[[HDL]])
-// CHECK:         %[[HDL_CAST3:.+]] = bitcast %"struct.std::experimental::coroutines_v1::coroutine_handle.0"* %[[HDL]] to i8*
+// CHECK:         %[[HDL_TRANSFER:.+]] = call i8* @_ZNKSt16coroutine_handleIvE7addressEv(%"struct.std::coroutine_handle.0"* {{.*}}%[[HDL]])
+// CHECK:         %[[HDL_CAST3:.+]] = bitcast %"struct.std::coroutine_handle.0"* %[[HDL]] to i8*
 // CHECK:         call void @llvm.lifetime.end.p0i8(i64 8, i8* %[[HDL_CAST3]])
 // CHECK:         call void @llvm.coro.resume(i8* %[[HDL_TRANSFER]])

clang/test/CodeGenCoroutines/coro-symmetric-transfer-02.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -O1 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
 
 #include "Inputs/coroutine.h"
 
-namespace coro = std::experimental::coroutines_v1;
-
 struct Task {
   struct promise_type {
     Task get_return_object() noexcept {
-      return Task{coro::coroutine_handle<promise_type>::from_promise(*this)};
+      return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
     }
 
     void return_void() noexcept {}
 
     struct final_awaiter {
       bool await_ready() noexcept { return false; }
-      coro::coroutine_handle<> await_suspend(coro::coroutine_handle<promise_type> h) noexcept {
+      std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h) noexcept {
         h.destroy();
         return {};
       }
       void await_resume() noexcept {}
     };
 
     void unhandled_exception() noexcept {}
 
     final_awaiter final_suspend() noexcept { return {}; }
 
-    coro::suspend_always initial_suspend() noexcept { return {}; }
+    std::suspend_always initial_suspend() noexcept { return {}; }
 
     template <typename Awaitable>
     auto await_transform(Awaitable &&awaitable) {
       return awaitable.co_viaIfAsync();
     }
   };
 
-  using handle_t = coro::coroutine_handle<promise_type>;
+  using handle_t = std::coroutine_handle<promise_type>;
 
   class Awaiter {
   public:
     explicit Awaiter(handle_t coro) noexcept;
     Awaiter(Awaiter &&other) noexcept;
     Awaiter(const Awaiter &) = delete;
     ~Awaiter();
 
     bool await_ready() noexcept { return false; }
-    handle_t await_suspend(coro::coroutine_handle<> continuation) noexcept;
+    handle_t await_suspend(std::coroutine_handle<> continuation) noexcept;
     void await_resume();
 
   private:
     handle_t coro_;
   };
 
   Task(handle_t coro) noexcept : coro_(coro) {}
 

 // CHECK-NEXT:      i32 1, label %[[CASE1:.+]]
 // CHECK-NEXT:      i32 2, label %[[CASE2:.+]]
 // CHECK-NEXT:    ]
 
 // CHECK:       [[CASE1]]:
 // CHECK:         br i1 %{{.+}}, label %[[CASE1_AWAIT_READY:.+]], label %[[CASE1_AWAIT_SUSPEND:.+]]
 // CHECK:       [[CASE1_AWAIT_SUSPEND]]:
 // CHECK-NEXT:    %{{.+}} = call token @llvm.coro.save(i8* null)
-// CHECK-NEXT:    %[[HANDLE11:.+]] = bitcast %"struct.std::experimental::coroutines_v1::coroutine_handle"* %[[TMP1:.+]] to i8*
+// CHECK-NEXT:    %[[HANDLE11:.+]] = bitcast %"struct.std::coroutine_handle"* %[[TMP1:.+]] to i8*
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 8, i8* %[[HANDLE11]])
 
-// CHECK:         %[[HANDLE12:.+]] = bitcast %"struct.std::experimental::coroutines_v1::coroutine_handle"* %[[TMP1]] to i8*
+// CHECK:         %[[HANDLE12:.+]] = bitcast %"struct.std::coroutine_handle"* %[[TMP1]] to i8*
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 8, i8* %[[HANDLE12]])
 // CHECK-NEXT:    call void @llvm.coro.resume
 // CHECK-NEXT:    %{{.+}} = call i8 @llvm.coro.suspend
 // CHECK-NEXT:    switch i8 %{{.+}}, label %coro.ret [
 // CHECK-NEXT:      i8 0, label %[[CASE1_AWAIT_READY]]
 // CHECK-NEXT:      i8 1, label %[[CASE1_AWAIT_CLEANUP:.+]]
 // CHECK-NEXT:    ]
 // CHECK:       [[CASE1_AWAIT_CLEANUP]]:
 // make sure that the awaiter eventually gets cleaned up.
 // CHECK:         call void @{{.+Awaiter.+}}
 
 // CHECK:       [[CASE2]]:
 // CHECK:         br i1 %{{.+}}, label %[[CASE2_AWAIT_READY:.+]], label %[[CASE2_AWAIT_SUSPEND:.+]]
 // CHECK:       [[CASE2_AWAIT_SUSPEND]]:
 // CHECK-NEXT:    %{{.+}} = call token @llvm.coro.save(i8* null)
-// CHECK-NEXT:    %[[HANDLE21:.+]] = bitcast %"struct.std::experimental::coroutines_v1::coroutine_handle"* %[[TMP2:.+]] to i8*
+// CHECK-NEXT:    %[[HANDLE21:.+]] = bitcast %"struct.std::coroutine_handle"* %[[TMP2:.+]] to i8*
 // CHECK-NEXT:    call void @llvm.lifetime.start.p0i8(i64 8, i8* %[[HANDLE21]])
 
-// CHECK:         %[[HANDLE22:.+]] = bitcast %"struct.std::experimental::coroutines_v1::coroutine_handle"* %[[TMP2]] to i8*
+// CHECK:         %[[HANDLE22:.+]] = bitcast %"struct.std::coroutine_handle"* %[[TMP2]] to i8*
 // CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 8, i8* %[[HANDLE22]])
 // CHECK-NEXT:    call void @llvm.coro.resume
 // CHECK-NEXT:    %{{.+}} = call i8 @llvm.coro.suspend
 // CHECK-NEXT:    switch i8 %{{.+}}, label %coro.ret [
 // CHECK-NEXT:      i8 0, label %[[CASE2_AWAIT_READY]]
 // CHECK-NEXT:      i8 1, label %[[CASE2_AWAIT_CLEANUP:.+]]
 // CHECK-NEXT:    ]
 // CHECK:       [[CASE2_AWAIT_CLEANUP]]:
 // make sure that the awaiter eventually gets cleaned up.
 // CHECK:         call void @{{.+Awaiter.+}}

clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp

 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -triple=x86_64-pc-windows-msvc18.0.0 -emit-llvm %s -o - -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck %s
 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck --check-prefix=CHECK-LPAD %s
 
 #include "Inputs/coroutine.h"
 
-namespace coro = std::experimental::coroutines_v1;
-
 namespace std {
   using exception_ptr = int;
   exception_ptr current_exception();
 }
 
 struct coro_t {
   struct promise_type {
     coro_t get_return_object() {
-      coro::coroutine_handle<promise_type>{};
+      std::coroutine_handle<promise_type>{};
       return {};
     }
-    coro::suspend_never initial_suspend() { return {}; }
-    coro::suspend_never final_suspend() noexcept { return {}; }
+    std::suspend_never initial_suspend() { return {}; }
+    std::suspend_never final_suspend() noexcept { return {}; }
     void return_void(){}
     void unhandled_exception() noexcept;
   };
 };
 
 struct Cleanup { ~Cleanup(); };
 void may_throw();
 

 // CHECK:   %[[CATCHTOK:.+]] = catchpad within [[CATCHSWTOK:.+]]
 // CHECK:   call void @"?unhandled_exception@promise_type@coro_t@@QEAAXXZ"
 // CHECK:   catchret from %[[CATCHTOK]] to label %[[CATCHRETDEST:.+]]
 // CHECK: [[CATCHRETDEST]]:
 // CHECK-NEXT: br label %[[TRYCONT:.+]]
 // CHECK: [[TRYCONT]]:
 // CHECK-NEXT: br label %[[COROFIN:.+]]
 // CHECK: [[COROFIN]]:
-// CHECK-NEXT: bitcast %"struct.std::experimental::coroutines_v1::suspend_never"* %{{.+}} to i8*
+// CHECK-NEXT: bitcast %"struct.std::suspend_never"* %{{.+}} to i8*
 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(
-// CHECK-NEXT: call void @"?final_suspend@promise_type@coro_t@@QEAA?AUsuspend_never@coroutines_v1@experimental@std@@XZ"(
+// CHECK-NEXT: call void @"?final_suspend@promise_type@coro_t@@QEAA?AUsuspend_never@std@@XZ"(
 
 // CHECK-LPAD: @_Z1fv(
 // CHECK-LPAD:   invoke void @_Z9may_throwv()
 // CHECK-LPAD:       to label %[[CONT:.+]] unwind label %[[CLEANUP:.+]]
 // CHECK-LPAD: [[CLEANUP]]:
 // CHECK-LPAD:   call void @_ZN7CleanupD1Ev(%struct.Cleanup* {{[^,]*}} %x) #2
 // CHECK-LPAD:   br label %[[CATCH:.+]]
 
 // CHECK-LPAD: [[CATCH]]:
 // CHECK-LPAD:    call i8* @__cxa_begin_catch
 // CHECK-LPAD:    call void @_ZN6coro_t12promise_type19unhandled_exceptionEv(%"struct.coro_t::promise_type"* {{[^,]*}} %__promise) #2
 // CHECK-LPAD:    invoke void @__cxa_end_catch()
 // CHECK-LPAD-NEXT:  to label %[[CATCHRETDEST:.+]] unwind label
 // CHECK-LPAD: [[CATCHRETDEST]]:
 // CHECK-LPAD-NEXT: br label %[[TRYCONT:.+]]
 // CHECK-LPAD: [[TRYCONT]]:
 // CHECK-LPAD: br label %[[COROFIN:.+]]
 // CHECK-LPAD: [[COROFIN]]:
-// CHECK-LPAD-NEXT: bitcast %"struct.std::experimental::coroutines_v1::suspend_never"* %{{.+}} to i8*
+// CHECK-LPAD-NEXT: bitcast %"struct.std::suspend_never"* %{{.+}} to i8*
 // CHECK-LPAD-NEXT: call void @llvm.lifetime.start.p0i8(
 // CHECK-LPAD-NEXT: call void @_ZN6coro_t12promise_type13final_suspendEv(

clang/test/CoverageMapping/coroutine.cpp

 // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping %s -o - | FileCheck %s
 
-namespace std::experimental {
+namespace std {
 template <typename... T>
 struct coroutine_traits;
 
 template <class Promise = void>
 struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept { return {}; }
 };
 template <>
 struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) { return {}; }
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept {}
 };
-} // namespace std::experimental
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
 template <>
-struct std::experimental::coroutine_traits<int, int> {
+struct std::coroutine_traits<int, int> {
   struct promise_type {
     int get_return_object();
     suspend_always initial_suspend();
     suspend_always final_suspend() noexcept;
     void return_value(int);
   };
 };
 

clang/test/Index/coroutines.cpp

 // RUN: c-index-test -test-load-source all -c %s -fsyntax-only -target x86_64-apple-darwin9 -fcoroutines-ts -std=c++1z -I%S/../SemaCXX/Inputs | FileCheck %s
 #include "std-coroutine.h"
 
-using std::experimental::suspend_always;
-using std::experimental::suspend_never;
+using std::suspend_always;
+using std::suspend_never;
 
 struct promise_void {
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_void();
   void unhandled_exception();
 };
 
 template <>
-struct std::experimental::coroutine_traits<void> { using promise_type = promise_void; };
+struct std::coroutine_traits<void> { using promise_type = promise_void; };
 
 void CoroutineTestRet() {
   co_return;
 }
 // CHECK: [[@LINE-3]]:25: UnexposedStmt=
 // CHECK-SAME: [[@LINE-4]]:25 - [[@LINE-2]]:2]
 // CHECK: [[@LINE-4]]:3: UnexposedStmt=
 // CHECK-SAME: [[@LINE-5]]:3 - [[@LINE-5]]:12]

clang/test/PCH/coroutines.cpp

 // Test this without pch.
 // RUN: %clang_cc1 -include %s -verify -std=c++1z -fcoroutines-ts %s
 
 // Test with pch.
 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts  -emit-pch -o %t %s
 // RUN: %clang_cc1 -include-pch %t -verify -std=c++1z -fcoroutines-ts %s
 
 #ifndef HEADER
 #define HEADER
 
-namespace std::experimental {
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
-template <typename... Args> struct std::experimental::coroutine_traits<void, Args...> {
+template <typename... Args> struct std::coroutine_traits<void, Args...> {
   struct promise_type {
     void get_return_object() noexcept;
     suspend_always initial_suspend() noexcept;
     suspend_always final_suspend() noexcept;
     void return_void() noexcept;
     suspend_always yield_value(int) noexcept;
     promise_type();
     ~promise_type() noexcept;
     void unhandled_exception() noexcept;
   };
 };
 
-template <typename... Args> struct std::experimental::coroutine_traits<int, Args...> {
+template <typename... Args> struct std::coroutine_traits<int, Args...> {
   struct promise_type {
     int get_return_object() noexcept;
     suspend_always initial_suspend() noexcept;
     suspend_always final_suspend() noexcept;
     void return_value(int) noexcept;
     promise_type();
     ~promise_type() noexcept;
     void unhandled_exception() noexcept;

clang/test/SemaCXX/Inputs/std-coroutine-exp-namespace.h

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wno-unreachable-code -Wno-unused-value
+#ifndef STD_COROUTINE_EXPERIMENTAL_H
+#define STD_COROUTINE_EXPERIMENTAL_H
+
+namespace std {
+namespace experimental {
+template <class Ret, typename... T>
+struct coroutine_traits { using promise_type = typename Ret::promise_type; };
+
+template <class Promise = void>
+struct coroutine_handle {
+  static coroutine_handle from_address(void *) noexcept;
+};
+template <>
+struct coroutine_handle<void> {
+  template <class PromiseType>
+  coroutine_handle(coroutine_handle<PromiseType>) noexcept;
+  static coroutine_handle from_address(void *);
+};
+
+struct suspend_always {
+  bool await_ready() noexcept { return false; }
+  void await_suspend(coroutine_handle<>) noexcept {}
+  void await_resume() noexcept {}
+};
+
+struct suspend_never {
+  bool await_ready() noexcept { return true; }
+  void await_suspend(coroutine_handle<>) noexcept {}
+  void await_resume() noexcept {}
+};
+} // namespace experimental
+} // namespace std
+
+#endif // STD_COROUTINE_EXPERIMENTAL_H

clang/test/SemaCXX/Inputs/std-coroutine.h

 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wno-unreachable-code -Wno-unused-value
 #ifndef STD_COROUTINE_H
 #define STD_COROUTINE_H
 
 namespace std {
-namespace experimental {
 
 template <class Ret, typename... T>
 struct coroutine_traits { using promise_type = typename Ret::promise_type; };
 
 template <class Promise = void>
 struct coroutine_handle {
   static coroutine_handle from_address(void *) noexcept;
 };

 };
 
 struct suspend_never {
   bool await_ready() noexcept { return true; }
   void await_suspend(coroutine_handle<>) noexcept {}
   void await_resume() noexcept {}
 };
 
-} // namespace experimental
 } // namespace std
 
 #endif // STD_COROUTINE_H

clang/test/SemaCXX/co_await-range-for-exp-namespace.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
+// RUN:    -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify \
+// RUN:    -fblocks
+#include "Inputs/std-coroutine-exp-namespace.h"
+
+using namespace std::experimental;
+
+template <class Begin>
+struct Awaiter {
+  bool await_ready();
+  void await_suspend(coroutine_handle<>);
+  Begin await_resume();
+};
+
+template <class Iter> struct BeginTag { BeginTag() = delete; };
+template <class Iter> struct IncTag { IncTag() = delete; };
+
+template <class Iter, bool Delete = false>
+struct CoawaitTag { CoawaitTag() = delete; };
+
+template <class T>
+struct Iter {
+  using value_type = T;
+  using reference = T &;
+  using pointer = T *;
+
+  IncTag<Iter> operator++();
+  reference operator*();
+  pointer operator->();
+};
+template <class T> bool operator==(Iter<T>, Iter<T>);
+template <class T> bool operator!=(Iter<T>, Iter<T>);
+
+template <class T>
+struct Range {
+  BeginTag<Iter<T>> begin();
+  Iter<T> end();
+};
+
+struct MyForLoopArrayAwaiter {
+  struct promise_type {
+    MyForLoopArrayAwaiter get_return_object() { return {}; }
+    void return_void();
+    void unhandled_exception();
+    suspend_never initial_suspend();
+    suspend_never final_suspend() noexcept;
+    template <class T>
+    Awaiter<T *> await_transform(T *) = delete; // expected-note {{explicitly deleted}}
+  };
+};
+MyForLoopArrayAwaiter g() {
+  int arr[10] = {0};
+  for co_await(auto i : arr) {}
+  // expected-error@-1 {{call to deleted member function 'await_transform'}}
+  // expected-note@-2 {{'await_transform' implicitly required by 'co_await' here}}
+}
+
+struct ForLoopAwaiterBadBeginTransform {
+  struct promise_type {
+    ForLoopAwaiterBadBeginTransform get_return_object();
+    void return_void();
+    void unhandled_exception();
+    suspend_never initial_suspend();
+    suspend_never final_suspend() noexcept;
+
+    template <class T>
+    Awaiter<T> await_transform(BeginTag<T>) = delete; // expected-note 1+ {{explicitly deleted}}
+
+    template <class T>
+    CoawaitTag<T> await_transform(IncTag<T>); // expected-note 1+ {{candidate}}
+  };
+};
+ForLoopAwaiterBadBeginTransform bad_begin() {
+  Range<int> R;
+  for co_await(auto i : R) {}
+  // expected-error@-1 {{call to deleted member function 'await_transform'}}
+  // expected-note@-2 {{'await_transform' implicitly required by 'co_await' here}}
+}
+template <class Dummy>
+ForLoopAwaiterBadBeginTransform bad_begin_template(Dummy) {
+  Range<Dummy> R;
+  for co_await(auto i : R) {}
+  // expected-error@-1 {{call to deleted member function 'await_transform'}}
+  // expected-note@-2 {{'await_transform' implicitly required by 'co_await' here}}
+}
+template ForLoopAwaiterBadBeginTransform bad_begin_template(int); // expected-note {{requested here}}
+
+template <class Iter>
+Awaiter<Iter> operator co_await(CoawaitTag<Iter, true>) = delete;
+// expected-note@-1 1+ {{explicitly deleted}}
+
+struct ForLoopAwaiterBadIncTransform {
+  struct promise_type {
+    ForLoopAwaiterBadIncTransform get_return_object();
+    void return_void();
+    void unhandled_exception();
+    suspend_never initial_suspend();
+    suspend_never final_suspend() noexcept;
+
+    template <class T>
+    Awaiter<T> await_transform(BeginTag<T> e);
+
+    template <class T>
+    CoawaitTag<T, true> await_transform(IncTag<T>);
+  };
+};
+ForLoopAwaiterBadIncTransform bad_inc_transform() {
+  Range<float> R;
+  for co_await(auto i : R) {}
+  // expected-error@-1 {{overload resolution selected deleted operator 'co_await'}}
+  // expected-note@-2 {{in implicit call to 'operator++' for iterator of type 'Range<float>'}}
+}
+
+template <class Dummy>
+ForLoopAwaiterBadIncTransform bad_inc_transform_template(Dummy) {
+  Range<Dummy> R;
+  for co_await(auto i : R) {}
+  // expected-error@-1 {{overload resolution selected deleted operator 'co_await'}}
+  // expected-note@-2 {{in implicit call to 'operator++' for iterator of type 'Range<long>'}}
+}
+template ForLoopAwaiterBadIncTransform bad_inc_transform_template(long); // expected-note {{requested here}}
+
+// Ensure we mark and check the function as a coroutine even if it's
+// never instantiated.
+template <class T>
+constexpr void never_instant(T) {
+  static_assert(sizeof(T) != sizeof(T), "function should not be instantiated");
+  for co_await(auto i : foo(T{})) {}
+  // expected-error@-1 {{'co_await' cannot be used in a constexpr function}}
+}
+
+namespace NS {
+struct ForLoopAwaiterCoawaitLookup {
+  struct promise_type {
+    ForLoopAwaiterCoawaitLookup get_return_object();
+    void return_void();
+    void unhandled_exception();
+    suspend_never initial_suspend();
+    suspend_never final_suspend() noexcept;
+    template <class T>
+    CoawaitTag<T, false> await_transform(BeginTag<T> e);
+    template <class T>
+    Awaiter<T> await_transform(IncTag<T>);
+  };
+};
+} // namespace NS
+using NS::ForLoopAwaiterCoawaitLookup;
+
+template <class T>
+ForLoopAwaiterCoawaitLookup test_coawait_lookup(T) {
+  Range<T> R;
+  for co_await(auto i : R) {}
+  // expected-error@-1 {{no member named 'await_ready' in 'CoawaitTag<Iter<int>, false>'}}
+}
+template ForLoopAwaiterCoawaitLookup test_coawait_lookup(int); // expected-note {{requested here}}
+
+// FIXME: This test should fail as well since the newly declared operator co_await
+// should not be found by lookup.
+namespace NS2 {
+template <class Iter>
+Awaiter<Iter> operator co_await(CoawaitTag<Iter, false>);
+}
+using NS2::operator co_await;
+template ForLoopAwaiterCoawaitLookup test_coawait_lookup(long);

clang/test/SemaCXX/co_await-range-for.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
 // RUN:    -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify \
 // RUN:    -fblocks
 #include "Inputs/std-coroutine.h"
 
-using namespace std::experimental;
-
+using namespace std;
 
 template <class Begin>
 struct Awaiter {
   bool await_ready();
   void await_suspend(coroutine_handle<>);
   Begin await_resume();
 };
 

clang/test/SemaCXX/coreturn-eh-exp-namespace.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fcxx-exceptions -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wall -Wextra -Wno-error=unreachable-code
+// expected-no-diagnostics
+
+#include "Inputs/std-coroutine-exp-namespace.h"
+
+using std::experimental::suspend_always;
+using std::experimental::suspend_never;
+
+struct awaitable {
+  bool await_ready();
+  void await_suspend(std::experimental::coroutine_handle<>); // FIXME: coroutine_handle
+  void await_resume();
+} a;
+
+struct object { ~object() {} };
+
+struct promise_void_return_value {
+  void get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  void return_value(object);
+};
+
+struct VoidTagReturnValue {
+  struct promise_type {
+    VoidTagReturnValue get_return_object();
+    suspend_always initial_suspend();
+    suspend_always final_suspend() noexcept;
+    void unhandled_exception();
+    void return_value(object);
+  };
+};
+
+template <typename T1>
+struct std::experimental::coroutine_traits<void, T1> { using promise_type = promise_void_return_value; };
+
+VoidTagReturnValue test() {
+  object x = {};
+  try {
+    co_return {};
+  } catch (...) {
+    throw;
+  }
+}

clang/test/SemaCXX/coreturn-eh.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fcxx-exceptions -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wall -Wextra -Wno-error=unreachable-code
 // expected-no-diagnostics
 
 #include "Inputs/std-coroutine.h"
 
-using std::experimental::suspend_always;
-using std::experimental::suspend_never;
+using std::suspend_always;
+using std::suspend_never;
 
 struct awaitable {
   bool await_ready();
-  void await_suspend(std::experimental::coroutine_handle<>); // FIXME: coroutine_handle
+  void await_suspend(std::coroutine_handle<>); // FIXME: coroutine_handle
   void await_resume();
 } a;
 
 struct object { ~object() {} };
 
 struct promise_void_return_value {
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void unhandled_exception();
   void return_value(object);
 };
 
 struct VoidTagReturnValue {
   struct promise_type {
     VoidTagReturnValue get_return_object();
     suspend_always initial_suspend();
     suspend_always final_suspend() noexcept;
     void unhandled_exception();
     void return_value(object);
   };
 };
 
 template <typename T1>
-struct std::experimental::coroutine_traits<void, T1> { using promise_type = promise_void_return_value; };
+struct std::coroutine_traits<void, T1> { using promise_type = promise_void_return_value; };
 
 VoidTagReturnValue test() {
   object x = {};
   try {
     co_return {};
   } catch (...) {
     throw;
   }
 }

clang/test/SemaCXX/coreturn-exp-namespace.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wall -Wextra -Wno-error=unreachable-code
+#include "Inputs/std-coroutine-exp-namespace.h"
+
+using std::experimental::suspend_always;
+using std::experimental::suspend_never;
+
+struct awaitable {
+  bool await_ready();
+  void await_suspend(std::experimental::coroutine_handle<>); // FIXME: coroutine_handle
+  void await_resume();
+} a;
+
+struct promise_void {
+  void get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+struct promise_void_return_value {
+  void get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  void return_value(int);
+};
+
+struct VoidTagNoReturn {
+  struct promise_type {
+    VoidTagNoReturn get_return_object();
+    suspend_always initial_suspend();
+    suspend_always final_suspend() noexcept;
+    void unhandled_exception();
+  };
+};
+
+struct VoidTagReturnValue {
+  struct promise_type {
+    VoidTagReturnValue get_return_object();
+    suspend_always initial_suspend();
+    suspend_always final_suspend() noexcept;
+    void unhandled_exception();
+    void return_value(int);
+  };
+};
+
+struct VoidTagReturnVoid {
+  struct promise_type {
+    VoidTagReturnVoid get_return_object();
+    suspend_always initial_suspend();
+    suspend_always final_suspend() noexcept;
+    void unhandled_exception();
+    void return_void();
+  };
+};
+
+struct promise_float {
+  float get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+struct promise_int {
+  int get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_value(int);
+  void unhandled_exception();
+};
+
+template <>
+struct std::experimental::coroutine_traits<void> { using promise_type = promise_void; };
+
+template <typename T1>
+struct std::experimental::coroutine_traits<void, T1> { using promise_type = promise_void_return_value; };
+
+template <typename... T>
+struct std::experimental::coroutine_traits<float, T...> { using promise_type = promise_float; };
+
+template <typename... T>
+struct std::experimental::coroutine_traits<int, T...> { using promise_type = promise_int; };
+
+void test0() { co_await a; }
+float test1() { co_await a; }
+
+int test2() {
+  co_await a;
+} // expected-warning {{non-void coroutine does not return a value}}
+
+int test2a(bool b) {
+  if (b)
+    co_return 42;
+} // expected-warning {{non-void coroutine does not return a value in all control paths}}
+
+int test3() {
+  co_await a;
+b:
+  goto b;
+}
+
+int test4() {
+  co_return 42;
+}
+
+void test5(int) {
+  co_await a;
+} // expected-warning {{non-void coroutine does not return a value}}
+
+void test6(int x) {
+  if (x)
+    co_return 42;
+} // expected-warning {{non-void coroutine does not return a value in all control paths}}
+
+void test7(int y) {
+  if (y)
+    co_return 42;
+  else
+    co_return 101;
+}
+
+VoidTagReturnVoid test8() {
+  co_await a;
+}
+
+VoidTagReturnVoid test9(bool b) {
+  if (b)
+    co_return;
+}
+
+VoidTagReturnValue test10() {
+  co_await a;
+} // expected-warning {{non-void coroutine does not return a value}}
+
+VoidTagReturnValue test11(bool b) {
+  if (b)
+    co_return 42;
+} // expected-warning {{non-void coroutine does not return a value in all control paths}}

clang/test/SemaCXX/coreturn.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wall -Wextra -Wno-error=unreachable-code
 #include "Inputs/std-coroutine.h"
 
-using std::experimental::suspend_always;
-using std::experimental::suspend_never;
+using std::suspend_always;
+using std::suspend_never;
 
 struct awaitable {
   bool await_ready();
-  void await_suspend(std::experimental::coroutine_handle<>); // FIXME: coroutine_handle
+  void await_suspend(std::coroutine_handle<>); // FIXME: coroutine_handle
   void await_resume();
 } a;
 
 struct promise_void {
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_void();
struct promise_int {
   int get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_value(int);
   void unhandled_exception();
 };
 
 template <>
-struct std::experimental::coroutine_traits<void> { using promise_type = promise_void; };
+struct std::coroutine_traits<void> { using promise_type = promise_void; };
 
 template <typename T1>
-struct std::experimental::coroutine_traits<void, T1> { using promise_type = promise_void_return_value; };
+struct std::coroutine_traits<void, T1> { using promise_type = promise_void_return_value; };
 
 template <typename... T>
-struct std::experimental::coroutine_traits<float, T...> { using promise_type = promise_float; };
+struct std::coroutine_traits<float, T...> { using promise_type = promise_float; };
 
 template <typename... T>
-struct std::experimental::coroutine_traits<int, T...> { using promise_type = promise_int; };
+struct std::coroutine_traits<int, T...> { using promise_type = promise_int; };
 
 void test0() { co_await a; }
 float test1() { co_await a; }
 
 int test2() {
   co_await a;
 } // expected-warning {{non-void coroutine does not return a value}}
 

clang/test/SemaCXX/coroutine-final-suspend-noexcept-exp-namespace.cpp

+// This file contains references to sections of the Coroutines TS, which can be
+// found at http://wg21.link/coroutines.
+
+// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -verify %s -fcxx-exceptions -fexceptions -Wunused-result
+
+namespace std {
+namespace experimental {
+template <class Ret, typename... T>
+struct coroutine_traits { using promise_type = typename Ret::promise_type; };
+
+template <class Promise = void>
+struct coroutine_handle {
+  static coroutine_handle from_address(void *); // expected-note 2 {{must be declared with 'noexcept'}}
+};
+template <>
+struct coroutine_handle<void> {
+  template <class PromiseType>
+  coroutine_handle(coroutine_handle<PromiseType>); // expected-note 2 {{must be declared with 'noexcept'}}
+};
+
+struct suspend_never {
+  bool await_ready() { return true; }       // expected-note 2 {{must be declared with 'noexcept'}}
+  void await_suspend(coroutine_handle<>) {} // expected-note 2 {{must be declared with 'noexcept'}}
+  void await_resume() {}                    // expected-note 2 {{must be declared with 'noexcept'}}
+  ~suspend_never() noexcept(false);         // expected-note 2 {{must be declared with 'noexcept'}}
+};
+
+struct suspend_always {
+  bool await_ready() { return false; }
+  void await_suspend(coroutine_handle<>) {}
+  void await_resume() {}
+  suspend_never operator co_await(); // expected-note 2 {{must be declared with 'noexcept'}}
+  ~suspend_always() noexcept(false); // expected-note 2 {{must be declared with 'noexcept'}}
+};
+} // namespace experimental
+} // namespace std
+
+using namespace std;
+
+struct A {
+  bool await_ready();
+  void await_resume();
+  template <typename F>
+  void await_suspend(F);
+};
+
+struct coro_t {
+  struct promise_type {
+    coro_t get_return_object();
+    std::experimental::suspend_never initial_suspend();
+    std::experimental::suspend_always final_suspend(); // expected-note 2 {{must be declared with 'noexcept'}}
+    void return_void();
+    static void unhandled_exception();
+  };
+};
+
+coro_t f(int n) { // expected-error {{the expression 'co_await __promise.final_suspend()' is required to be non-throwing}}
+  A a{};
+  co_await a;
+}
+
+template <typename T>
+coro_t f_dep(T n) { // expected-error {{the expression 'co_await __promise.final_suspend()' is required to be non-throwing}}
+  A a{};
+  co_await a;
+}
+
+void foo() {
+  f_dep<int>(5); // expected-note {{in instantiation of function template specialization 'f_dep<int>' requested here}}
+}

clang/test/SemaCXX/coroutine-final-suspend-noexcept.cpp

 // This file contains references to sections of the Coroutines TS, which can be
 // found at http://wg21.link/coroutines.
 
 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -verify %s -fcxx-exceptions -fexceptions -Wunused-result
 
 namespace std {
-namespace experimental {
 
 template <class Ret, typename... T>
 struct coroutine_traits { using promise_type = typename Ret::promise_type; };
 
 template <class Promise = void>
 struct coroutine_handle {
   static coroutine_handle from_address(void *); // expected-note 2 {{must be declared with 'noexcept'}}
 };

 struct suspend_always {
   bool await_ready() { return false; }
   void await_suspend(coroutine_handle<>) {}
   void await_resume() {}
   suspend_never operator co_await(); // expected-note 2 {{must be declared with 'noexcept'}}
   ~suspend_always() noexcept(false); // expected-note 2 {{must be declared with 'noexcept'}}
 };
 
-} // namespace experimental
 } // namespace std
 
-using namespace std::experimental;
+using namespace std;
 
 struct A {
   bool await_ready();
   void await_resume();
   template <typename F>
   void await_suspend(F);
 };
 

clang/test/SemaCXX/coroutine-rvo-exp-namespace.cpp

+// RUN: %clang_cc1 -verify -std=c++17 -fcoroutines-ts -fsyntax-only %s
+
+namespace std::experimental {
+template <class Promise = void> struct coroutine_handle {
+  coroutine_handle() = default;
+  static coroutine_handle from_address(void *) noexcept;
+};
+
+template <> struct coroutine_handle<void> {
+  static coroutine_handle from_address(void *) noexcept;
+  coroutine_handle() = default;
+  template <class PromiseType>
+  coroutine_handle(coroutine_handle<PromiseType>) noexcept;
+};
+
+template <class... Args>
+struct void_t_imp {
+  using type = void;
+};
+template <class... Args>
+using void_t = typename void_t_imp<Args...>::type;
+
+template <class T, class = void>
+struct traits_sfinae_base {};
+
+template <class T>
+struct traits_sfinae_base<T, void_t<typename T::promise_type>> {
+  using promise_type = typename T::promise_type;
+};
+
+template <class Ret, class... Args>
+struct coroutine_traits : public traits_sfinae_base<Ret> {};
+} // namespace std::experimental
+
+struct suspend_never {
+  bool await_ready() noexcept;
+  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_resume() noexcept;
+};
+
+struct MoveOnly {
+  MoveOnly() = default;
+  MoveOnly(const MoveOnly&) = delete;
+  MoveOnly(MoveOnly &&) = default;
+};
+
+struct NoCopyNoMove {
+  NoCopyNoMove() = default;
+  NoCopyNoMove(const NoCopyNoMove &) = delete;
+};
+
+template <typename T>
+struct task {
+  struct promise_type {
+    auto initial_suspend() { return suspend_never{}; }
+    auto final_suspend() noexcept { return suspend_never{}; }
+    auto get_return_object() { return task{}; }
+    static void unhandled_exception() {}
+    void return_value(T &&value) {} // expected-note 4{{passing argument}}
+  };
+};
+
+task<NoCopyNoMove> local2val() {
+  NoCopyNoMove value;
+  co_return value;
+}
+
+task<NoCopyNoMove &> local2ref() {
+  NoCopyNoMove value;
+  co_return value; // expected-error {{non-const lvalue reference to type 'NoCopyNoMove' cannot bind to a temporary of type 'NoCopyNoMove'}}
+}
+
+// We need the move constructor for construction of the coroutine.
+task<MoveOnly> param2val(MoveOnly value) {
+  co_return value;
+}
+
+task<NoCopyNoMove> lvalue2val(NoCopyNoMove &value) {
+  co_return value; // expected-error {{rvalue reference to type 'NoCopyNoMove' cannot bind to lvalue of type 'NoCopyNoMove'}}
+}
+
+task<NoCopyNoMove> rvalue2val(NoCopyNoMove &&value) {
+  co_return value;
+}
+
+task<NoCopyNoMove &> lvalue2ref(NoCopyNoMove &value) {
+  co_return value;
+}
+
+task<NoCopyNoMove &> rvalue2ref(NoCopyNoMove &&value) {
+  co_return value; // expected-error {{non-const lvalue reference to type 'NoCopyNoMove' cannot bind to a temporary of type 'NoCopyNoMove'}}
+}
+
+struct To {
+  operator MoveOnly() &&;
+};
+task<MoveOnly> conversion_operator() {
+  To t;
+  co_return t;
+}
+
+struct Construct {
+  Construct(MoveOnly);
+};
+task<Construct> converting_constructor() {
+  MoveOnly w;
+  co_return w;
+}
+
+struct Derived : MoveOnly {};
+task<MoveOnly> derived2base() {
+  Derived result;
+  co_return result;
+}
+
+struct RetThis {
+  task<RetThis> foo() && {
+    co_return *this; // expected-error {{rvalue reference to type 'RetThis' cannot bind to lvalue of type 'RetThis'}}
+  }
+};
+
+template <typename, typename>
+struct is_same { static constexpr bool value = false; };
+
+template <typename T>
+struct is_same<T, T> { static constexpr bool value = true; };
+
+template <typename T>
+struct generic_task {
+  struct promise_type {
+    auto initial_suspend() { return suspend_never{}; }
+    auto final_suspend() noexcept { return suspend_never{}; }
+    auto get_return_object() { return generic_task{}; }
+    static void unhandled_exception();
+    template <typename U>
+    void return_value(U &&value) {
+      static_assert(is_same<T, U>::value);
+    }
+  };
+};
+
+generic_task<MoveOnly> param2template(MoveOnly value) {
+  co_return value; // We should deduce U = MoveOnly.
+}
+
+generic_task<NoCopyNoMove &> lvalue2template(NoCopyNoMove &value) {
+  co_return value; // We should deduce U = NoCopyNoMove&.
+}

clang/test/SemaCXX/coroutine-rvo.cpp

 // RUN: %clang_cc1 -verify -std=c++17 -fcoroutines-ts -fsyntax-only %s
 
-namespace std::experimental {
+namespace std {
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;

 
 template <class T>
 struct traits_sfinae_base<T, void_t<typename T::promise_type>> {
   using promise_type = typename T::promise_type;
 };
 
 template <class Ret, class... Args>
 struct coroutine_traits : public traits_sfinae_base<Ret> {};
-}
+} // namespace std
 
 struct suspend_never {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
 struct MoveOnly {
   MoveOnly() = default;
   MoveOnly(const MoveOnly&) = delete;
   MoveOnly(MoveOnly &&) = default;
 };

clang/test/SemaCXX/coroutine-seh-exp-namespace.cpp

+// RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -verify %s -fcxx-exceptions -fexceptions -triple x86_64-windows-msvc -fms-extensions
+namespace std::experimental {
+template <typename... T> struct coroutine_traits;
+
+template <class Promise = void> struct coroutine_handle {
+  coroutine_handle() = default;
+  static coroutine_handle from_address(void *) noexcept;
+};
+template <> struct coroutine_handle<void> {
+  static coroutine_handle from_address(void *) noexcept;
+  coroutine_handle() = default;
+  template <class PromiseType>
+  coroutine_handle(coroutine_handle<PromiseType>) noexcept;
+};
+} // namespace std::experimental
+
+struct suspend_always {
+  bool await_ready() noexcept;
+  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_resume() noexcept;
+};
+
+template <> struct std::experimental::coroutine_traits<void> {
+  struct promise_type {
+    void get_return_object() noexcept;
+    suspend_always initial_suspend() noexcept;
+    suspend_always final_suspend() noexcept;
+    void return_void() noexcept;
+    void unhandled_exception() noexcept;
+  };
+};
+
+void SEH_used() {
+  __try { // expected-error {{cannot use SEH '__try' in a coroutine when C++ exceptions are enabled}}
+    co_return; // expected-note {{function is a coroutine due to use of 'co_return' here}}
+  } __except(0) {}
+}

clang/test/SemaCXX/coroutine-seh.cpp

 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -verify %s -fcxx-exceptions -fexceptions -triple x86_64-windows-msvc -fms-extensions
-namespace std::experimental {
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
 template <> struct coroutine_handle<void> {
   static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std
 
 struct suspend_always {
   bool await_ready() noexcept;
-  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
   void await_resume() noexcept;
 };
 
-template <> struct std::experimental::coroutine_traits<void> {
+template <> struct std::coroutine_traits<void> {
   struct promise_type {
     void get_return_object() noexcept;
     suspend_always initial_suspend() noexcept;
     suspend_always final_suspend() noexcept;
     void return_void() noexcept;
     void unhandled_exception() noexcept;
   };
 };
 
 void SEH_used() {
   __try { // expected-error {{cannot use SEH '__try' in a coroutine when C++ exceptions are enabled}}
     co_return; // expected-note {{function is a coroutine due to use of 'co_return' here}}
   } __except(0) {}
 }

clang/test/SemaCXX/coroutine-traits-undefined-template-exp-namespace.cpp

+// This file contains references to sections of the Coroutines TS, which can be
+// found at http://wg21.link/coroutines.
+
+// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -verify %s -fcxx-exceptions -fexceptions -Wunused-result
+
+namespace std {
+namespace experimental {
+template<typename ...T>
+struct coroutine_traits {
+  struct promise_type {};
+};
+
+template <> struct coroutine_traits<void>; // expected-note {{forward declaration of 'std::experimental::coroutine_traits<void>'}}
+}} // namespace std::experimental 
+
+void uses_forward_declaration() {
+  co_return; // expected-error {{this function cannot be a coroutine: missing definition of specialization 'coroutine_traits<void>'}}
+}

clang/test/SemaCXX/coroutine-traits-undefined-template.cpp

 // This file contains references to sections of the Coroutines TS, which can be
 // found at http://wg21.link/coroutines.
 
 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -verify %s -fcxx-exceptions -fexceptions -Wunused-result
 
 namespace std {
-namespace experimental {
 
 template<typename ...T>
 struct coroutine_traits {
   struct promise_type {};
 };
 
-template<> struct coroutine_traits<void>; // expected-note {{forward declaration of 'std::experimental::coroutine_traits<void>'}}
-}} // namespace std::experimental
+template <> struct coroutine_traits<void>; // expected-note {{forward declaration of 'std::coroutine_traits<void>'}}
+} // namespace std
 
 void uses_forward_declaration() {
   co_return; // expected-error {{this function cannot be a coroutine: missing definition of specialization 'coroutine_traits<void>'}}
 }

clang/test/SemaCXX/coroutine-unhandled_exception-warning-exp-namespace.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
+// RUN:    -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify \
+// RUN:    -fblocks -Wno-unreachable-code -Wno-unused-value
+
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
+// RUN:    -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify \
+// RUN:    -fblocks -Wno-unreachable-code -Wno-unused-value \
+// RUN:    -DDISABLE_WARNING -Wno-coroutine-missing-unhandled-exception
+
+#if __has_feature(cxx_exceptions)
+#error This test requires exceptions be disabled
+#endif
+
+#include "Inputs/std-coroutine-exp-namespace.h"
+
+using std::experimental::suspend_always;
+using std::experimental::suspend_never;
+
+#ifndef DISABLE_WARNING
+struct promise_void { // expected-note {{defined here}}
+#else
+struct promise_void {
+#endif
+  void get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+};
+
+template <typename... T>
+struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise_void; };
+
+#ifndef DISABLE_WARNING
+void test0() { // expected-warning {{'promise_void' is required to declare the member 'unhandled_exception()' when exceptions are enabled}}
+  co_return;
+}
+#else
+void test0() { // expected-no-diagnostics
+  co_return;
+}
+#endif

clang/test/SemaCXX/coroutine-unhandled_exception-warning.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
 // RUN:    -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify \
 // RUN:    -fblocks -Wno-unreachable-code -Wno-unused-value
 
 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
 // RUN:    -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify \
 // RUN:    -fblocks -Wno-unreachable-code -Wno-unused-value \
 // RUN:    -DDISABLE_WARNING -Wno-coroutine-missing-unhandled-exception
 
 #if __has_feature(cxx_exceptions)
 #error This test requires exceptions be disabled
 #endif
 
 #include "Inputs/std-coroutine.h"
 
-using std::experimental::suspend_always;
-using std::experimental::suspend_never;
+using std::suspend_always;
+using std::suspend_never;
 
 #ifndef DISABLE_WARNING
 struct promise_void { // expected-note {{defined here}}
 #else
 struct promise_void {
 #endif
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_void();
 };
 
 template <typename... T>
-struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise_void; };
+struct std::coroutine_traits<void, T...> { using promise_type = promise_void; };
 
 #ifndef DISABLE_WARNING
 void test0() { // expected-warning {{'promise_void' is required to declare the member 'unhandled_exception()' when exceptions are enabled}}
   co_return;
 }
 #else
 void test0() { // expected-no-diagnostics
   co_return;
 }
 #endif

clang/test/SemaCXX/coroutine-uninitialized-warning-crash-exp-namespace.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wall -Wextra -Wuninitialized  -fblocks
+#include "Inputs/std-coroutine-exp-namespace.h"
+
+using namespace std::experimental;
+
+struct A {
+  bool await_ready() { return true; }
+  int await_resume() { return 42; }
+  template <typename F>
+  void await_suspend(F) {}
+};
+
+
+struct coro_t {
+  struct promise_type {
+    coro_t get_return_object() { return {}; }
+    suspend_never initial_suspend() { return {}; }
+    suspend_never final_suspend() noexcept { return {}; }
+    A yield_value(int) { return {}; }
+    void return_void() {}
+    static void unhandled_exception() {}
+  };
+};
+
+coro_t f(int n) {
+  if (n == 0)
+    co_return;
+  co_yield 42;
+  int x = co_await A{};
+}
+
+template <class Await>
+coro_t g(int n) {
+  if (n == 0)
+    co_return;
+  co_yield 42;
+  int x = co_await Await{};
+}
+
+int main() {
+  f(0);
+  g<A>(0);
+}

clang/test/SemaCXX/coroutine-uninitialized-warning-crash.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wall -Wextra -Wuninitialized  -fblocks
 #include "Inputs/std-coroutine.h"
 
-using namespace std::experimental;
-
+using namespace std;
 
 struct A {
   bool await_ready() { return true; }
   int await_resume() { return 42; }
   template <typename F>
   void await_suspend(F) {}
 };
 

clang/test/SemaCXX/coroutine_handle-address-return-type.cpp

+// RUN: %clang_cc1 -verify %s -stdlib=libc++ -std=c++1z -fcoroutines-ts -fsyntax-only
+
+namespace std {
+template <class Promise = void>
+struct coroutine_handle;
+
+template <>
+struct coroutine_handle<void> {
+  coroutine_handle() = default;
+  static coroutine_handle from_address(void *) noexcept;
+  void *address() const;
+};
+
+template <class Promise>
+struct coroutine_handle : public coroutine_handle<> {
+};
+
+template <class... Args>
+struct void_t_imp {
+  using type = void;
+};
+template <class... Args>
+using void_t = typename void_t_imp<Args...>::type;
+
+template <class T, class = void>
+struct traits_sfinae_base {};
+
+template <class T>
+struct traits_sfinae_base<T, void_t<typename T::promise_type>> {
+  using promise_type = typename T::promise_type;
+};
+
+template <class Ret, class... Args>
+struct coroutine_traits : public traits_sfinae_base<Ret> {};
+} // namespace std
+
+struct suspend_never {
+  bool await_ready() noexcept;
+  void await_suspend(std::coroutine_handle<>) noexcept;
+  void await_resume() noexcept;
+};
+
+struct task {
+  struct promise_type {
+    auto initial_suspend() { return suspend_never{}; }
+    auto final_suspend() noexcept { return suspend_never{}; }
+    auto get_return_object() { return task{}; }
+    static void unhandled_exception() {}
+    void return_void() {}
+  };
+};
+
+namespace std {
+template <>
+struct coroutine_handle<task::promise_type> : public coroutine_handle<> {
+  coroutine_handle<task::promise_type> *address() const; // expected-warning {{return type of 'coroutine_handle<>::address should be 'void*'}}
+};
+} // namespace std
+
+struct awaitable {
+  bool await_ready();
+
+  std::coroutine_handle<task::promise_type>
+  await_suspend(std::coroutine_handle<> handle);
+  void await_resume();
+} a;
+
+task f() {
+  co_await a;
+}
+
+int main() {
+  f();
+  return 0;
+}

clang/test/SemaCXX/coroutines-exp-namespace.cpp

+// This file is the same as coroutines.cpp, except the components are defined in namespace std::experimental.
+// The intent of this test is to make sure the std::experimental implementation still works.
+// TODO: Remove this test once we drop support for <experimental/coroutine>.
+
+// RUN: %clang_cc1 -std=c++2b                 -fsyntax-only -verify=expected,cxx20_2b,cxx2b    %s -fcxx-exceptions -fexceptions -Wunused-result
+// RUN: %clang_cc1 -std=c++20                 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result
+// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -fsyntax-only -verify=expected,cxx14_20          %s -fcxx-exceptions -fexceptions -Wunused-result
+
+void no_coroutine_traits_bad_arg_await() {
+  co_await a; // expected-error {{include <experimental/coroutine>}}
+  // expected-error@-1 {{use of undeclared identifier 'a'}}
+}
+
+void no_coroutine_traits_bad_arg_yield() {
+  co_yield a; // expected-error {{include <experimental/coroutine>}}
+  // expected-error@-1 {{use of undeclared identifier 'a'}}
+}
+
+void no_coroutine_traits_bad_arg_return() {
+  co_return a; // expected-error {{include <experimental/coroutine>}}
+  // expected-error@-1 {{use of undeclared identifier 'a'}}
+}
+
+void no_coroutine_traits() {
+  co_await 4; // expected-error {{std::coroutine_traits type was not found; include <coroutine> before defining a coroutine; include <experimental/coroutine> if your version of libcxx is less than 14.0}}
+}
+
+namespace std {
+namespace experimental {
+
+template <class... Args>
+struct void_t_imp {
+  using type = void;
+};
+template <class... Args>
+using void_t = typename void_t_imp<Args...>::type;
+
+template <class T, class = void>
+struct traits_sfinae_base {};
+
+template <class T>
+struct traits_sfinae_base<T, void_t<typename T::promise_type>> {
+  using promise_type = typename T::promise_type;
+};
+
+template <class Ret, class... Args>
+struct coroutine_traits : public traits_sfinae_base<Ret> {};
+} // namespace experimental
+} // namespace std
+
+template <typename Promise> struct coro {};
+template <typename Promise, typename... Ps>
+struct std::experimental::coroutine_traits<coro<Promise>, Ps...> {
+  using promise_type = Promise;
+};
+
+struct awaitable {
+  bool await_ready() noexcept;
+  template <typename F>
+  void await_suspend(F) noexcept;
+  void await_resume() noexcept;
+} a;
+
+struct suspend_always {
+  bool await_ready() noexcept { return false; }
+  template <typename F>
+  void await_suspend(F) noexcept;
+  void await_resume() noexcept {}
+};
+
+struct suspend_never {
+  bool await_ready() noexcept { return true; }
+  template <typename F>
+  void await_suspend(F) noexcept;
+  void await_resume() noexcept {}
+};
+
+struct auto_await_suspend {
+  bool await_ready();
+  template <typename F> auto await_suspend(F) {}
+  void await_resume();
+};
+
+struct DummyVoidTag {};
+DummyVoidTag no_specialization() { // expected-error {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<DummyVoidTag>' has no member named 'promise_type'}}
+  co_await a;
+}
+
+template <typename... T>
+struct std::experimental::coroutine_traits<int, T...> {};
+
+int no_promise_type() { // expected-error {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<int>' has no member named 'promise_type'}}
+  co_await a;
+}
+
+int no_promise_type_multiple_awaits(int) { // expected-error {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<int, int>' has no member named 'promise_type'}}
+  co_await a;
+  co_await a;
+}
+
+template <>
+struct std::experimental::coroutine_traits<double, double> { typedef int promise_type; };
+double bad_promise_type(double) { // expected-error {{this function cannot be a coroutine: 'experimental::coroutine_traits<double, double>::promise_type' (aka 'int') is not a class}}
+  co_await a;
+}
+
+template <>
+struct std::experimental::coroutine_traits<double, int> {
+  struct promise_type {};
+};
+double bad_promise_type_2(int) { // expected-error {{no member named 'initial_suspend'}}
+  co_yield 0;                    // expected-error {{no member named 'yield_value' in 'std::experimental::coroutine_traits<double, int>::promise_type'}}
+}
+
+struct promise; // expected-note {{forward declaration}}
+struct promise_void;
+struct void_tag {};
+template <typename... T>
+struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise; };
+template <typename... T>
+struct std::experimental::coroutine_traits<void, void_tag, T...> { using promise_type = promise_void; };
+
+// FIXME: This diagnostic is terrible.
+void undefined_promise() { // expected-error {{this function cannot be a coroutine: 'experimental::coroutine_traits<void>::promise_type' (aka 'promise') is an incomplete type}}
+  co_await a;
+}
+
+struct yielded_thing {
+  const char *p;
+  short a, b;
+};
+
+struct not_awaitable {};
+
+struct promise {
+  void get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  awaitable yield_value(int);           // expected-note 2{{candidate}}
+  awaitable yield_value(yielded_thing); // expected-note 2{{candidate}}
+  not_awaitable yield_value(void());    // expected-note 2{{candidate}}
+  void return_value(int);               // expected-note 2{{here}}
+  void unhandled_exception();
+};
+
+struct promise_void {
+  void get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+void no_coroutine_handle() { // expected-error {{std::coroutine_handle type was not found; include <coroutine> before defining a coroutine; include <experimental/coroutine> if your version of libcxx is less than 14.0}}
+  //expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
+  co_return 5; //expected-note {{function is a coroutine due to use of 'co_return' here}}
+}
+
+namespace std {
+namespace experimental {
+template <class PromiseType = void>
+struct coroutine_handle {
+  static coroutine_handle from_address(void *) noexcept;
+};
+template <>
+struct coroutine_handle<void> {
+  template <class PromiseType>
+  coroutine_handle(coroutine_handle<PromiseType>) noexcept;
+  static coroutine_handle from_address(void *) noexcept;
+};
+} // namespace experimental
+} // namespace std
+
+void yield() {
+  co_yield 0;
+  co_yield {"foo", 1, 2};
+  co_yield {1e100};                    // expected-error {{cannot be narrowed}} expected-note {{explicit cast}} expected-warning {{implicit conversion}} expected-warning {{braces around scalar}}
+  co_yield {"foo", __LONG_LONG_MAX__}; // expected-error {{cannot be narrowed}} expected-note {{explicit cast}} expected-warning {{changes value}}
+  co_yield {"foo"};
+  co_yield "foo"; // expected-error {{no matching}}
+  co_yield 1.0;
+  co_yield yield; // expected-error {{no member named 'await_ready' in 'not_awaitable'}}
+}
+
+void check_auto_await_suspend() {
+  co_await auto_await_suspend{}; // Should compile successfully.
+}
+
+void coreturn(int n) {
+  co_await a;
+  if (n == 0)
+    co_return 3;
+  if (n == 1)
+    co_return {4}; // expected-warning {{braces around scalar initializer}}
+  if (n == 2)
+    co_return "foo"; // expected-error {{cannot initialize a parameter of type 'int' with an lvalue of type 'const char[4]'}}
+  co_return 42;
+}
+
+template <class T>
+void co_await_non_dependent_arg(T) {
+  co_await a;
+}
+template void co_await_non_dependent_arg(int);
+
+void mixed_yield() {
+  co_yield 0; // expected-note {{use of 'co_yield'}}
+  return;     // expected-error {{not allowed in coroutine}}
+}
+
+void mixed_yield_invalid() {
+  co_yield blah; // expected-error {{use of undeclared identifier}}
+  // expected-note@-1 {{function is a coroutine due to use of 'co_yield'}}
+  return; // expected-error {{return statement not allowed in coroutine}}
+}
+
+template <class T>
+void mixed_yield_template(T) {
+  co_yield blah; // expected-error {{use of undeclared identifier}}
+  // expected-note@-1 {{function is a coroutine due to use of 'co_yield'}}
+  return; // expected-error {{return statement not allowed in coroutine}}
+}
+
+template <class T>
+void mixed_yield_template2(T) {
+  co_yield 42;
+  // expected-note@-1 {{function is a coroutine due to use of 'co_yield'}}
+  return; // expected-error {{return statement not allowed in coroutine}}
+}
+
+template <class T>
+void mixed_yield_template3(T v) {
+  co_yield blah(v);
+  // expected-note@-1 {{function is a coroutine due to use of 'co_yield'}}
+  return; // expected-error {{return statement not allowed in coroutine}}
+}
+
+void mixed_await() {
+  co_await a; // expected-note {{use of 'co_await'}}
+  return;     // expected-error {{not allowed in coroutine}}
+}
+
+void mixed_await_invalid() {
+  co_await 42; // expected-error {{'int' is not a structure or union}}
+  // expected-note@-1 {{function is a coroutine due to use of 'co_await'}}
+  return; // expected-error {{not allowed in coroutine}}
+}
+
+template <class T>
+void mixed_await_template(T) {
+  co_await 42;
+  // expected-note@-1 {{function is a coroutine due to use of 'co_await'}}
+  return; // expected-error {{not allowed in coroutine}}
+}
+
+template <class T>
+void mixed_await_template2(T v) {
+  co_await v; // expected-error {{'long' is not a structure or union}}
+  // expected-note@-1 {{function is a coroutine due to use of 'co_await'}}
+  return; // expected-error {{not allowed in coroutine}}
+}
+template void mixed_await_template2(long); // expected-note {{requested here}}
+
+void only_coreturn(void_tag) {
+  co_return; // OK
+}
+
+void mixed_coreturn(void_tag, bool b) {
+  if (b)
+    co_return; // expected-note {{use of 'co_return'}}
+  else
+    return; // expected-error {{not allowed in coroutine}}
+}
+
+void mixed_coreturn_invalid(bool b) {
+  if (b)
+    co_return; // expected-note {{use of 'co_return'}}
+  // expected-error@-1 {{no member named 'return_void' in 'promise'}}
+  else
+    return; // expected-error {{not allowed in coroutine}}
+}
+
+template <class T>
+void mixed_coreturn_template(void_tag, bool b, T v) {
+  if (b)
+    co_return v; // expected-note {{use of 'co_return'}}
+  // expected-error@-1 {{no member named 'return_value' in 'promise_void'}}
+  else
+    return; // expected-error {{not allowed in coroutine}}
+}
+template void mixed_coreturn_template(void_tag, bool, int); // expected-note {{requested here}}
+
+template <class T>
+void mixed_coreturn_template2(bool b, T) {
+  if (b)
+    co_return v; // expected-note {{use of 'co_return'}}
+  // expected-error@-1 {{use of undeclared identifier 'v'}}
+  else
+    return; // expected-error {{not allowed in coroutine}}
+}
+
+struct CtorDtor {
+  CtorDtor() {
+    co_yield 0; // expected-error {{'co_yield' cannot be used in a constructor}}
+  }
+  CtorDtor(awaitable a) {
+    // The spec doesn't say this is ill-formed, but it must be.
+    co_await a; // expected-error {{'co_await' cannot be used in a constructor}}
+  }
+  ~CtorDtor() {
+    co_return 0; // expected-error {{'co_return' cannot be used in a destructor}}
+  }
+  void operator=(CtorDtor &) {
+    co_yield 0; // OK.
+  }
+  void operator=(CtorDtor const &) {
+    co_yield 0; // OK.
+  }
+  void operator=(CtorDtor &&) {
+    co_await a; // OK.
+  }
+  void operator=(CtorDtor const &&) {
+    co_await a; // OK.
+  }
+  void operator=(int) {
+    co_await a; // OK. Not a special member
+  }
+};
+
+namespace std {
+class type_info;
+}
+
+void unevaluated() {
+  decltype(co_await a); // expected-error {{'co_await' cannot be used in an unevaluated context}}
+                        // expected-warning@-1 {{declaration does not declare anything}}
+  sizeof(co_await a);   // expected-error {{'co_await' cannot be used in an unevaluated context}}
+                        // expected-error@-1 {{invalid application of 'sizeof' to an incomplete type 'void'}}
+                        // expected-warning@-2 {{expression with side effects has no effect in an unevaluated context}}
+  typeid(co_await a);   // expected-error {{'co_await' cannot be used in an unevaluated context}}
+                        // expected-warning@-1 {{expression with side effects has no effect in an unevaluated context}}
+                        // expected-warning@-2 {{expression result unused}}
+  decltype(co_yield 1); // expected-error {{'co_yield' cannot be used in an unevaluated context}}
+                        // expected-warning@-1 {{declaration does not declare anything}}
+  sizeof(co_yield 2);   // expected-error {{'co_yield' cannot be used in an unevaluated context}}
+                        // expected-error@-1 {{invalid application of 'sizeof' to an incomplete type 'void'}}
+                        // expected-warning@-2 {{expression with side effects has no effect in an unevaluated context}}
+  typeid(co_yield 3);   // expected-error {{'co_yield' cannot be used in an unevaluated context}}
+                        // expected-warning@-1 {{expression with side effects has no effect in an unevaluated context}}
+                        // expected-warning@-2 {{expression result unused}}
+}
+
+// [expr.await]p2: "An await-expression shall not appear in a default argument."
+// FIXME: A better diagnostic would explicitly state that default arguments are
+// not allowed. A user may not understand that this is "outside a function."
+void default_argument(int arg = co_await 0) {} // expected-error {{'co_await' cannot be used outside a function}}
+
+void await_in_catch_coroutine() {
+  try {
+  } catch (...) {                   // FIXME: Emit a note diagnostic pointing out the try handler on this line.
+    []() -> void { co_await a; }(); // OK
+    co_await a;                     // expected-error {{'co_await' cannot be used in the handler of a try block}}
+  }
+}
+
+void await_nested_in_catch_coroutine() {
+  try {
+  } catch (...) { // FIXME: Emit a note diagnostic pointing out the try handler on this line.
+    try {
+      co_await a;                     // expected-error {{'co_await' cannot be used in the handler of a try block}}
+      []() -> void { co_await a; }(); // OK
+    } catch (...) {
+      co_return 123;
+    }
+  }
+}
+
+void await_in_lambda_in_catch_coroutine() {
+  try {
+  } catch (...) {
+    []() -> void { co_await a; }(); // OK
+  }
+}
+
+void yield_in_catch_coroutine() {
+  try {
+  } catch (...) {
+    co_yield 1; // expected-error {{'co_yield' cannot be used in the handler of a try block}}
+  }
+}
+
+void return_in_catch_coroutine() {
+  try {
+  } catch (...) {
+    co_return 123; // OK
+  }
+}
+
+constexpr auto constexpr_deduced_return_coroutine() {
+  co_yield 0; // expected-error {{'co_yield' cannot be used in a constexpr function}}
+  // expected-error@-1 {{'co_yield' cannot be used in a function with a deduced return type}}
+}
+
+void varargs_coroutine(const char *, ...) {
+  co_await a; // expected-error {{'co_await' cannot be used in a varargs function}}
+}
+
+auto deduced_return_coroutine() {
+  co_await a; // expected-error {{'co_await' cannot be used in a function with a deduced return type}}
+}
+
+struct outer {};
+struct await_arg_1 {};
+struct await_arg_2 {};
+
+namespace adl_ns {
+struct coawait_arg_type {};
+awaitable operator co_await(coawait_arg_type) noexcept;
+} // namespace adl_ns
+
+namespace dependent_operator_co_await_lookup {
+template <typename T> void await_template(T t) {
+  // no unqualified lookup results
+  co_await t; // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::not_awaitable'}}
+  // expected-error@-1 {{call to function 'operator co_await' that is neither visible in the template definition nor found by argument-dependent lookup}}
+};
+template void await_template(awaitable);
+
+struct indirectly_awaitable {
+  indirectly_awaitable(outer);
+};
+awaitable operator co_await(indirectly_awaitable); // expected-note {{should be declared prior to}}
+template void await_template(indirectly_awaitable);
+
+struct not_awaitable {};
+template void await_template(not_awaitable); // expected-note {{instantiation}}
+
+template <typename T> void await_template_2(T t) {
+  // one unqualified lookup result
+  co_await t;
+};
+template void await_template(outer); // expected-note {{instantiation}}
+template void await_template_2(outer);
+
+struct transform_awaitable {};
+struct transformed {};
+
+struct transform_promise {
+  typedef transform_awaitable await_arg;
+  coro<transform_promise> get_return_object();
+  transformed initial_suspend();
+  ::adl_ns::coawait_arg_type final_suspend() noexcept;
+  transformed await_transform(transform_awaitable);
+  void unhandled_exception();
+  void return_void();
+};
+template <class AwaitArg>
+struct basic_promise {
+  typedef AwaitArg await_arg;
+  coro<basic_promise> get_return_object();
+  awaitable initial_suspend();
+  awaitable final_suspend() noexcept;
+  void unhandled_exception();
+  void return_void();
+};
+
+awaitable operator co_await(await_arg_1);
+
+template <typename T, typename U>
+coro<T> await_template_3(U t) {
+  co_await t;
+}
+
+template coro<basic_promise<await_arg_1>> await_template_3<basic_promise<await_arg_1>>(await_arg_1);
+
+template <class T, int I = 0>
+struct dependent_member {
+  coro<T> mem_fn() const {
+    co_await typename T::await_arg{}; // expected-error {{call to function 'operator co_await'}}}
+  }
+  template <class U>
+  coro<T> dep_mem_fn(U t) {
+    co_await t;
+  }
+};
+
+template <>
+struct dependent_member<long> {
+  // FIXME this diagnostic is terrible
+  coro<transform_promise> mem_fn() const { // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::transformed'}}
+    // expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
+    // expected-note@+1 {{function is a coroutine due to use of 'co_await' here}}
+    co_await transform_awaitable{};
+    // expected-error@-1 {{no member named 'await_ready'}}
+  }
+  template <class R, class U>
+  coro<R> dep_mem_fn(U u) { co_await u; }
+};
+
+awaitable operator co_await(await_arg_2); // expected-note {{'operator co_await' should be declared prior to the call site}}
+
+template struct dependent_member<basic_promise<await_arg_1>, 0>;
+template struct dependent_member<basic_promise<await_arg_2>, 0>; // expected-note {{in instantiation}}
+
+template <>
+coro<transform_promise>
+// FIXME this diagnostic is terrible
+dependent_member<long>::dep_mem_fn<transform_promise>(int) { // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::transformed'}}
+  //expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
+  //expected-note@+1 {{function is a coroutine due to use of 'co_await' here}}
+  co_await transform_awaitable{};
+  // expected-error@-1 {{no member named 'await_ready'}}
+}
+
+void operator co_await(transform_awaitable) = delete;
+awaitable operator co_await(transformed);
+
+template coro<transform_promise>
+    dependent_member<long>::dep_mem_fn<transform_promise>(transform_awaitable);
+
+template <>
+coro<transform_promise> dependent_member<long>::dep_mem_fn<transform_promise>(long) {
+  co_await transform_awaitable{};
+}
+
+template <>
+struct dependent_member<int> {
+  coro<transform_promise> mem_fn() const {
+    co_await transform_awaitable{};
+  }
+};
+
+template coro<transform_promise> await_template_3<transform_promise>(transform_awaitable);
+template struct dependent_member<transform_promise>;
+template coro<transform_promise> dependent_member<transform_promise>::dep_mem_fn(transform_awaitable);
+} // namespace dependent_operator_co_await_lookup
+
+struct yield_fn_tag {};
+template <>
+struct std::experimental::coroutine_traits<void, yield_fn_tag> {
+  struct promise_type {
+    // FIXME: add an await_transform overload for functions
+    awaitable yield_value(int());
+    void return_value(int());
+
+    suspend_never initial_suspend();
+    suspend_never final_suspend() noexcept;
+    void get_return_object();
+    void unhandled_exception();
+  };
+};
+
+namespace placeholder {
+awaitable f(), f(int); // expected-note 4{{possible target}}
+int g(), g(int);       // expected-note 2{{candidate}}
+void x() {
+  co_await f; // expected-error {{reference to overloaded function}}
+}
+void y() {
+  co_yield g; // expected-error {{no matching member function for call to 'yield_value'}}
+}
+void z() {
+  co_await a;
+  co_return g; // expected-error {{address of overloaded function 'g' does not match required type 'int'}}
+}
+
+void x(yield_fn_tag) {
+  co_await f; // expected-error {{reference to overloaded function}}
+}
+void y(yield_fn_tag) {
+  co_yield g;
+}
+void z(yield_fn_tag) {
+  co_await a;
+  co_return g;
+}
+} // namespace placeholder
+
+struct bad_promise_1 {
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  void return_void();
+};
+coro<bad_promise_1> missing_get_return_object() { // expected-error {{no member named 'get_return_object' in 'bad_promise_1'}}
+  co_await a;
+}
+
+struct bad_promise_2 {
+  coro<bad_promise_2> get_return_object();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  void return_void();
+};
+// FIXME: This shouldn't happen twice
+coro<bad_promise_2> missing_initial_suspend() { // expected-error {{no member named 'initial_suspend' in 'bad_promise_2'}}
+  co_await a;
+}
+
+struct bad_promise_3 {
+  coro<bad_promise_3> get_return_object();
+  suspend_always initial_suspend();
+  void unhandled_exception();
+  void return_void();
+};
+coro<bad_promise_3> missing_final_suspend() noexcept { // expected-error {{no member named 'final_suspend' in 'bad_promise_3'}}
+  co_await a;
+}
+
+struct bad_promise_4 {
+  coro<bad_promise_4> get_return_object();
+  not_awaitable initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+};
+// FIXME: This diagnostic is terrible.
+coro<bad_promise_4> bad_initial_suspend() { // expected-error {{no member named 'await_ready' in 'not_awaitable'}}
+  // expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
+  co_await a; // expected-note {{function is a coroutine due to use of 'co_await' here}}
+}
+
+struct bad_promise_5 {
+  coro<bad_promise_5> get_return_object();
+  suspend_always initial_suspend();
+  not_awaitable final_suspend() noexcept;
+  void return_void();
+};
+// FIXME: This diagnostic is terrible.
+coro<bad_promise_5> bad_final_suspend() { // expected-error {{no member named 'await_ready' in 'not_awaitable'}}
+  // expected-note@-1 {{call to 'final_suspend' implicitly required by the final suspend point}}
+  co_await a; // expected-note {{function is a coroutine due to use of 'co_await' here}}
+}
+
+struct bad_promise_6 {
+  coro<bad_promise_6> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  void return_void();           // expected-note 2 {{member 'return_void' first declared here}}
+  void return_value(int) const; // expected-note 2 {{member 'return_value' first declared here}}
+  void return_value(int);
+};
+coro<bad_promise_6> bad_implicit_return() { // expected-error {{'bad_promise_6' declares both 'return_value' and 'return_void'}}
+  co_await a;
+}
+
+template <class T>
+coro<T> bad_implicit_return_dependent(T) { // expected-error {{'bad_promise_6' declares both 'return_value' and 'return_void'}}
+  co_await a;
+}
+template coro<bad_promise_6> bad_implicit_return_dependent(bad_promise_6); // expected-note {{in instantiation}}
+
+struct bad_promise_7 { // expected-note 2 {{defined here}}
+  coro<bad_promise_7> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+};
+coro<bad_promise_7> no_unhandled_exception() { // expected-error {{'bad_promise_7' is required to declare the member 'unhandled_exception()'}}
+  co_await a;
+}
+
+template <class T>
+coro<T> no_unhandled_exception_dependent(T) { // expected-error {{'bad_promise_7' is required to declare the member 'unhandled_exception()'}}
+  co_await a;
+}
+template coro<bad_promise_7> no_unhandled_exception_dependent(bad_promise_7); // expected-note {{in instantiation}}
+
+struct bad_promise_base {
+private:
+  void return_void(); // expected-note 2 {{declared private here}}
+};
+struct bad_promise_8 : bad_promise_base {
+  coro<bad_promise_8> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception() __attribute__((unavailable)); // expected-note 2 {{marked unavailable here}}
+  void unhandled_exception() const;
+  void unhandled_exception(void *) const;
+};
+coro<bad_promise_8> calls_unhandled_exception() {
+  // expected-error@-1 {{'unhandled_exception' is unavailable}}
+  // expected-error@-2 {{'return_void' is a private member}}
+  co_await a;
+}
+
+template <class T>
+coro<T> calls_unhandled_exception_dependent(T) {
+  // expected-error@-1 {{'unhandled_exception' is unavailable}}
+  // expected-error@-2 {{'return_void' is a private member}}
+  co_await a;
+}
+template coro<bad_promise_8> calls_unhandled_exception_dependent(bad_promise_8); // expected-note {{in instantiation}}
+
+struct bad_promise_9 {
+  coro<bad_promise_9> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void await_transform(void *);
+  awaitable await_transform(int) __attribute__((unavailable)); // expected-note {{explicitly marked unavailable}}
+  void return_void();
+  void unhandled_exception();
+};
+coro<bad_promise_9> calls_await_transform() {
+  co_await 42; // expected-error {{'await_transform' is unavailable}}
+}
+
+struct bad_promise_10 {
+  coro<bad_promise_10> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  int await_transform;
+  void return_void();
+  void unhandled_exception();
+};
+coro<bad_promise_10> bad_coawait() {
+  // FIXME this diagnostic is terrible
+  co_await 42; // expected-error {{called object type 'int' is not a function or function pointer}}
+  // expected-note@-1 {{call to 'await_transform' implicitly required by 'co_await' here}}
+}
+
+struct call_operator {
+  template <class... Args>
+  awaitable operator()(Args...) const { return a; }
+};
+void ret_void();
+struct good_promise_1 {
+  coro<good_promise_1> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  static const call_operator await_transform;
+  using Fn = void (*)();
+  Fn return_void = ret_void;
+};
+const call_operator good_promise_1::await_transform;
+coro<good_promise_1> ok_static_coawait() {
+  // FIXME this diagnostic is terrible
+  co_await 42;
+}
+
+template <typename T> void ok_generic_lambda_coawait_PR41909() {
+  [](auto &arg) -> coro<good_promise_1> { // expected-warning {{expression result unused}}
+    co_await 12;
+  };
+  [](auto &arg) -> coro<good_promise_1> {
+    co_await 24;
+  }("argument");
+  [](auto &arg) -> coro<good_promise_1> { // expected-warning {{expression result unused}}
+    []() -> coro<good_promise_1> {
+      co_await 36;
+    };
+    co_await 48;
+  };
+}
+template void ok_generic_lambda_coawait_PR41909<int>(); // expected-note {{in instantiation of function template specialization 'ok_generic_lambda_coawait_PR41909<int>' requested here}}
+
+template <> struct std::experimental::coroutine_traits<int, int, const char **> { using promise_type = promise; };
+
+int main(int, const char **) {
+  co_await a; // expected-error {{'co_await' cannot be used in the 'main' function}}
+}
+
+struct good_promise_2 {
+  float get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+template <> struct std::experimental::coroutine_handle<good_promise_2> {};
+
+template <> struct std::experimental::coroutine_traits<float> { using promise_type = good_promise_2; };
+
+float badly_specialized_coro_handle() { // expected-error {{std::coroutine_handle missing a member named 'from_address'}}
+  //expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
+  co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
+}
+
+namespace std {
+struct nothrow_t {};
+constexpr nothrow_t nothrow = {};
+} // namespace std
+
+using SizeT = decltype(sizeof(int));
+
+void *operator new(SizeT __sz, const std::nothrow_t &) noexcept;
+void operator delete(void *__p, const std::nothrow_t &)noexcept;
+
+struct promise_on_alloc_failure_tag {};
+
+template <>
+struct std::experimental::coroutine_traits<int, promise_on_alloc_failure_tag> {
+  struct promise_type {
+    int get_return_object() {}
+    suspend_always initial_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+    int get_return_object_on_allocation_failure(); // expected-error{{'promise_type': 'get_return_object_on_allocation_failure()' must be a static member function}}
+    void unhandled_exception();
+  };
+};
+
+extern "C" int f(promise_on_alloc_failure_tag) {
+  co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
+}
+
+struct bad_promise_11 {
+  coro<bad_promise_11> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  void return_void();
+
+private:
+  static coro<bad_promise_11> get_return_object_on_allocation_failure(); // expected-note 2 {{declared private here}}
+};
+coro<bad_promise_11> private_alloc_failure_handler() {
+  // expected-error@-1 {{'get_return_object_on_allocation_failure' is a private member of 'bad_promise_11'}}
+  co_return; // FIXME: Add a "declared coroutine here" note.
+}
+
+template <class T>
+coro<T> dependent_private_alloc_failure_handler(T) {
+  // expected-error@-1 {{'get_return_object_on_allocation_failure' is a private member of 'bad_promise_11'}}
+  co_return; // FIXME: Add a "declared coroutine here" note.
+}
+template coro<bad_promise_11> dependent_private_alloc_failure_handler(bad_promise_11);
+// expected-note@-1 {{requested here}}
+
+struct bad_promise_12 {
+  coro<bad_promise_12> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  void return_void();
+  static coro<bad_promise_12> get_return_object_on_allocation_failure();
+
+  static void *operator new(SizeT);
+  // expected-error@-1 2 {{'operator new' is required to have a non-throwing noexcept specification when the promise type declares 'get_return_object_on_allocation_failure()'}}
+};
+coro<bad_promise_12> throwing_in_class_new() { // expected-note {{call to 'operator new' implicitly required by coroutine function here}}
+  co_return;
+}
+
+template <class T>
+coro<T> dependent_throwing_in_class_new(T) { // expected-note {{call to 'operator new' implicitly required by coroutine function here}}
+  co_return;
+}
+template coro<bad_promise_12> dependent_throwing_in_class_new(bad_promise_12); // expected-note {{requested here}}
+
+struct good_promise_13 {
+  coro<good_promise_13> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+  void return_void();
+  static coro<good_promise_13> get_return_object_on_allocation_failure();
+};
+coro<good_promise_13> uses_nothrow_new() {
+  co_return;
+}
+
+template <class T>
+coro<T> dependent_uses_nothrow_new(T) {
+  co_return;
+}
+template coro<good_promise_13> dependent_uses_nothrow_new(good_promise_13);
+
+struct good_promise_custom_new_operator {
+  coro<good_promise_custom_new_operator> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+  void *operator new(SizeT, double, float, int);
+};
+
+coro<good_promise_custom_new_operator>
+good_coroutine_calls_custom_new_operator(double, float, int) {
+  co_return;
+}
+
+struct coroutine_nonstatic_member_struct;
+
+struct good_promise_nonstatic_member_custom_new_operator {
+  coro<good_promise_nonstatic_member_custom_new_operator> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+  void *operator new(SizeT, coroutine_nonstatic_member_struct &, double);
+};
+
+struct good_promise_noexcept_custom_new_operator {
+  static coro<good_promise_noexcept_custom_new_operator> get_return_object_on_allocation_failure();
+  coro<good_promise_noexcept_custom_new_operator> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+  void *operator new(SizeT, double, float, int) noexcept;
+};
+
+coro<good_promise_noexcept_custom_new_operator>
+good_coroutine_calls_noexcept_custom_new_operator(double, float, int) {
+  co_return;
+}
+
+struct mismatch_gro_type_tag1 {};
+template <>
+struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag1> {
+  struct promise_type {
+    void get_return_object() {} //expected-note {{member 'get_return_object' declared here}}
+    suspend_always initial_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception();
+  };
+};
+
+extern "C" int f(mismatch_gro_type_tag1) {
+  // expected-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void'}}
+  co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
+}
+
+struct mismatch_gro_type_tag2 {};
+template <>
+struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag2> {
+  struct promise_type {
+    void *get_return_object() {} //expected-note {{member 'get_return_object' declared here}}
+    suspend_always initial_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception();
+  };
+};
+
+extern "C" int f(mismatch_gro_type_tag2) {
+  // cxx2b-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void *'}}
+  // cxx14_20-error@-2 {{cannot initialize return object of type 'int' with an lvalue of type 'void *'}}
+  co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
+}
+
+struct mismatch_gro_type_tag3 {};
+template <>
+struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag3> {
+  struct promise_type {
+    int get_return_object() {}
+    static void get_return_object_on_allocation_failure() {} //expected-note {{member 'get_return_object_on_allocation_failure' declared here}}
+    suspend_always initial_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception();
+  };
+};
+
+extern "C" int f(mismatch_gro_type_tag3) {
+  // expected-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void'}}
+  co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
+}
+
+struct mismatch_gro_type_tag4 {};
+template <>
+struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag4> {
+  struct promise_type {
+    int get_return_object() {}
+    static char *get_return_object_on_allocation_failure() {} //expected-note {{member 'get_return_object_on_allocation_failure' declared}}
+    suspend_always initial_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception();
+  };
+};
+
+extern "C" int f(mismatch_gro_type_tag4) {
+  // expected-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'char *'}}
+  co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
+}
+
+struct bad_promise_no_return_func { // expected-note {{'bad_promise_no_return_func' defined here}}
+  coro<bad_promise_no_return_func> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void unhandled_exception();
+};
+// FIXME: The PDTS currently specifies this as UB, technically forbidding a
+// diagnostic.
+coro<bad_promise_no_return_func> no_return_value_or_return_void() {
+  // expected-error@-1 {{'bad_promise_no_return_func' must declare either 'return_value' or 'return_void'}}
+  co_await a;
+}
+
+struct bad_await_suspend_return {
+  bool await_ready();
+  // expected-error@+1 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'char')}}
+  char await_suspend(std::experimental::coroutine_handle<>);
+  void await_resume();
+};
+struct bad_await_ready_return {
+  // expected-note@+1 {{return type of 'await_ready' is required to be contextually convertible to 'bool'}}
+  void await_ready();
+  bool await_suspend(std::experimental::coroutine_handle<>);
+  void await_resume();
+};
+struct await_ready_explicit_bool {
+  struct BoolT {
+    explicit operator bool() const;
+  };
+  BoolT await_ready();
+  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_resume();
+};
+template <class SuspendTy>
+struct await_suspend_type_test {
+  bool await_ready();
+  // expected-error@+2 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &')}}
+  // expected-error@+1 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &&')}}
+  SuspendTy await_suspend(std::experimental::coroutine_handle<>);
+  // cxx20_2b-warning@-1 {{volatile-qualified return type 'const volatile bool' is deprecated}}
+  void await_resume();
+};
+void test_bad_suspend() {
+  {
+    // FIXME: The actual error emitted here is terrible, and no number of notes can save it.
+    bad_await_ready_return a;
+    // expected-error@+1 {{value of type 'void' is not contextually convertible to 'bool'}}
+    co_await a; // expected-note {{call to 'await_ready' implicitly required by coroutine function here}}
+  }
+  {
+    bad_await_suspend_return b;
+    co_await b; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
+  }
+  {
+    await_ready_explicit_bool c;
+    co_await c; // OK
+  }
+  {
+    await_suspend_type_test<bool &&> a;
+    await_suspend_type_test<bool &> b;
+    await_suspend_type_test<const void> c;
+    await_suspend_type_test<const volatile bool> d; // cxx20_2b-note {{in instantiation of template class}}
+    co_await a;                                     // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
+    co_await b;                                     // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
+    co_await c;                                     // OK
+    co_await d;                                     // OK
+  }
+}
+
+template <int ID = 0>
+struct NoCopy {
+  NoCopy(NoCopy const &) = delete; // expected-note 2 {{deleted here}}
+};
+template <class T, class U>
+void test_dependent_param(T t, U) {
+  // expected-error@-1 {{call to deleted constructor of 'NoCopy<0>'}}
+  // expected-error@-2 {{call to deleted constructor of 'NoCopy<1>'}}
+  ((void)t);
+  co_return 42;
+}
+template void test_dependent_param(NoCopy<0>, NoCopy<1>); // expected-note {{requested here}}
+
+namespace CoroHandleMemberFunctionTest {
+struct CoroMemberTag {};
+struct BadCoroMemberTag {};
+
+template <class T, class U>
+constexpr bool IsSameV = false;
+template <class T>
+constexpr bool IsSameV<T, T> = true;
+
+template <class T>
+struct TypeTest {
+  template <class U>
+  static constexpr bool IsSame = IsSameV<T, U>;
+
+  template <class... Args>
+  static constexpr bool MatchesArgs = IsSameV<T,
+                                              std::experimental::coroutine_traits<CoroMemberTag, Args...>>;
+};
+
+template <class T>
+struct AwaitReturnsType {
+  bool await_ready() const;
+  void await_suspend(...) const;
+  T await_resume() const;
+};
+
+template <class... CoroTraitsArgs>
+struct CoroMemberPromise {
+  using TraitsT = std::experimental::coroutine_traits<CoroTraitsArgs...>;
+  using TypeTestT = TypeTest<TraitsT>;
+  using AwaitTestT = AwaitReturnsType<TypeTestT>;
+
+  CoroMemberTag get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+
+  AwaitTestT yield_value(int);
+
+  void return_void();
+  void unhandled_exception();
+};
+
+} // namespace CoroHandleMemberFunctionTest
+
+template <class... Args>
+struct ::std::experimental::coroutine_traits<CoroHandleMemberFunctionTest::CoroMemberTag, Args...> {
+  using promise_type = CoroHandleMemberFunctionTest::CoroMemberPromise<CoroHandleMemberFunctionTest::CoroMemberTag, Args...>;
+};
+
+namespace CoroHandleMemberFunctionTest {
+struct TestType {
+
+  CoroMemberTag test_qual() {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<TestType &>, "");
+    static_assert(!TC.MatchesArgs<TestType>, "");
+    static_assert(!TC.MatchesArgs<TestType *>, "");
+  }
+
+  CoroMemberTag test_sanity(int *) const {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
+    static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static_assert failed}}
+    static_assert(TC.MatchesArgs<const TestType &, int *>, "");
+  }
+
+  CoroMemberTag test_qual(int *, const float &&, volatile void *volatile) const {
+    // cxx20_2b-warning@-1 {{volatile-qualified parameter type}}
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<const TestType &, int *, const float &&, volatile void *volatile>, "");
+  }
+
+  CoroMemberTag test_qual() const volatile {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<const volatile TestType &>, "");
+  }
+
+  CoroMemberTag test_ref_qual() & {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<TestType &>, "");
+  }
+  CoroMemberTag test_ref_qual() const & {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<TestType const &>, "");
+  }
+  CoroMemberTag test_ref_qual() && {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<TestType &&>, "");
+  }
+  CoroMemberTag test_ref_qual(const char *&) const volatile && {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<TestType const volatile &&, const char *&>, "");
+  }
+
+  CoroMemberTag test_args(int) {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<TestType &, int>, "");
+  }
+  CoroMemberTag test_args(int, long &, void *) const {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<TestType const &, int, long &, void *>, "");
+  }
+
+  template <class... Args>
+  CoroMemberTag test_member_template(Args...) const && {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<TestType const &&, Args...>, "");
+  }
+
+  static CoroMemberTag test_static() {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<>, "");
+    static_assert(!TC.MatchesArgs<TestType>, "");
+    static_assert(!TC.MatchesArgs<TestType &>, "");
+    static_assert(!TC.MatchesArgs<TestType *>, "");
+  }
+
+  static CoroMemberTag test_static(volatile void *const, char &&) {
+    auto TC = co_yield 0;
+    static_assert(TC.MatchesArgs<volatile void *const, char &&>, "");
+  }
+
+  template <class Dummy>
+  static CoroMemberTag test_static_template(const char *volatile &, unsigned) {
+    auto TC = co_yield 0;
+    using TCT = decltype(TC);
+    static_assert(TCT::MatchesArgs<const char *volatile &, unsigned>, "");
+    static_assert(!TCT::MatchesArgs<TestType &, const char *volatile &, unsigned>, "");
+  }
+
+  BadCoroMemberTag test_diagnostics() {
+    // expected-error@-1 {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, CoroHandleMemberFunctionTest::TestType &>' has no member named 'promise_type'}}
+    co_return;
+  }
+  BadCoroMemberTag test_diagnostics(int) const && {
+    // expected-error@-1 {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, const CoroHandleMemberFunctionTest::TestType &&, int>' has no member named 'promise_type'}}
+    co_return;
+  }
+
+  static BadCoroMemberTag test_static_diagnostics(long *) {
+    // expected-error@-1 {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, long *>' has no member named 'promise_type'}}
+    co_return;
+  }
+};
+
+template CoroMemberTag TestType::test_member_template(long, const char *) const &&;
+template CoroMemberTag TestType::test_static_template<void>(const char *volatile &, unsigned);
+
+template <class... Args>
+struct DepTestType {
+
+  CoroMemberTag test_sanity(int *) const {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<const DepTestType &>, ""); // expected-error {{static_assert failed}}
+    static_assert(TC.template MatchesArgs<>, "");                    // expected-error {{static_assert failed}}
+    static_assert(TC.template MatchesArgs<const DepTestType &, int *>, "");
+  }
+
+  CoroMemberTag test_qual() {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<DepTestType &>, "");
+    static_assert(!TC.template MatchesArgs<DepTestType>, "");
+    static_assert(!TC.template MatchesArgs<DepTestType *>, "");
+  }
+
+  CoroMemberTag test_qual(int *, const float &&, volatile void *volatile) const {
+    // cxx20_2b-warning@-1 {{volatile-qualified parameter type}}
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<const DepTestType &, int *, const float &&, volatile void *volatile>, "");
+  }
+
+  CoroMemberTag test_qual() const volatile {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<const volatile DepTestType &>, "");
+  }
+
+  CoroMemberTag test_ref_qual() & {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<DepTestType &>, "");
+  }
+  CoroMemberTag test_ref_qual() const & {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<DepTestType const &>, "");
+  }
+  CoroMemberTag test_ref_qual() && {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<DepTestType &&>, "");
+  }
+  CoroMemberTag test_ref_qual(const char *&) const volatile && {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<DepTestType const volatile &&, const char *&>, "");
+  }
+
+  CoroMemberTag test_args(int) {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<DepTestType &, int>, "");
+  }
+  CoroMemberTag test_args(int, long &, void *) const {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<DepTestType const &, int, long &, void *>, "");
+  }
+
+  template <class... UArgs>
+  CoroMemberTag test_member_template(UArgs...) const && {
+    auto TC = co_yield 0;
+    static_assert(TC.template MatchesArgs<DepTestType const &&, UArgs...>, "");
+  }
+
+  static CoroMemberTag test_static() {
+    auto TC = co_yield 0;
+    using TCT = decltype(TC);
+    static_assert(TCT::MatchesArgs<>, "");
+    static_assert(!TCT::MatchesArgs<DepTestType>, "");
+    static_assert(!TCT::MatchesArgs<DepTestType &>, "");
+    static_assert(!TCT::MatchesArgs<DepTestType *>, "");
+
+    // Ensure diagnostics are actually being generated here
+    static_assert(TCT::MatchesArgs<int>, ""); // expected-error {{static_assert failed}}
+  }
+
+  static CoroMemberTag test_static(volatile void *const, char &&) {
+    auto TC = co_yield 0;
+    using TCT = decltype(TC);
+    static_assert(TCT::MatchesArgs<volatile void *const, char &&>, "");
+  }
+
+  template <class Dummy>
+  static CoroMemberTag test_static_template(const char *volatile &, unsigned) {
+    auto TC = co_yield 0;
+    using TCT = decltype(TC);
+    static_assert(TCT::MatchesArgs<const char *volatile &, unsigned>, "");
+    static_assert(!TCT::MatchesArgs<DepTestType &, const char *volatile &, unsigned>, "");
+  }
+};
+
+template struct DepTestType<int>; // expected-note {{requested here}}
+template CoroMemberTag DepTestType<int>::test_member_template(long, const char *) const &&;
+
+template CoroMemberTag DepTestType<int>::test_static_template<void>(const char *volatile &, unsigned);
+
+struct bad_promise_deleted_constructor {
+  // expected-note@+1 {{'bad_promise_deleted_constructor' has been explicitly marked deleted here}}
+  bad_promise_deleted_constructor() = delete;
+  coro<bad_promise_deleted_constructor> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+coro<bad_promise_deleted_constructor>
+bad_coroutine_calls_deleted_promise_constructor() {
+  // expected-error@-1 {{call to deleted constructor of 'std::experimental::coroutine_traits<coro<CoroHandleMemberFunctionTest::bad_promise_deleted_constructor>>::promise_type' (aka 'CoroHandleMemberFunctionTest::bad_promise_deleted_constructor')}}
+  co_return;
+}
+
+// Test that, when the promise type has a constructor whose signature matches
+// that of the coroutine function, that constructor is used. If no matching
+// constructor exists, the default constructor is used as a fallback. If no
+// matching constructors exist at all, an error is emitted. This is an
+// experimental feature that will be proposed for the Coroutines TS.
+
+struct good_promise_default_constructor {
+  good_promise_default_constructor(double, float, int);
+  good_promise_default_constructor() = default;
+  coro<good_promise_default_constructor> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+coro<good_promise_default_constructor>
+good_coroutine_calls_default_constructor() {
+  co_return;
+}
+
+struct some_class;
+
+struct good_promise_custom_constructor {
+  good_promise_custom_constructor(some_class &, float, int);
+  good_promise_custom_constructor(double, float, int);
+  good_promise_custom_constructor() = delete;
+  coro<good_promise_custom_constructor> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+coro<good_promise_custom_constructor>
+good_coroutine_calls_custom_constructor(double, float, int) {
+  co_return;
+}
+
+struct some_class {
+  coro<good_promise_custom_constructor>
+  good_coroutine_calls_custom_constructor(float, int) {
+    co_return;
+  }
+  coro<good_promise_custom_constructor> static good_coroutine_calls_custom_constructor(double, float, int) {
+    co_return;
+  }
+};
+
+struct bad_promise_no_matching_constructor {
+  bad_promise_no_matching_constructor(int, int, int);
+  // expected-note@+1 2 {{'bad_promise_no_matching_constructor' has been explicitly marked deleted here}}
+  bad_promise_no_matching_constructor() = delete;
+  coro<bad_promise_no_matching_constructor> get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+coro<bad_promise_no_matching_constructor>
+bad_coroutine_calls_with_no_matching_constructor(int, int) {
+  // expected-error@-1 {{call to deleted constructor of 'std::experimental::coroutine_traits<coro<CoroHandleMemberFunctionTest::bad_promise_no_matching_constructor>, int, int>::promise_type' (aka 'CoroHandleMemberFunctionTest::bad_promise_no_matching_constructor')}}
+  co_return;
+}
+
+struct some_class2 {
+  coro<bad_promise_no_matching_constructor>
+  bad_coroutine_calls_with_no_matching_constructor(int, int, int) {
+    // expected-error@-1 {{call to deleted constructor}}
+    co_return;
+  }
+};
+
+} // namespace CoroHandleMemberFunctionTest
+
+class awaitable_no_unused_warn {
+public:
+  using handle_type = std::experimental::coroutine_handle<>;
+  constexpr bool await_ready() noexcept { return false; }
+  void await_suspend(handle_type) noexcept {}
+  int await_resume() noexcept { return 1; }
+};
+
+class awaitable_unused_warn {
+public:
+  using handle_type = std::experimental::coroutine_handle<>;
+  constexpr bool await_ready() noexcept { return false; }
+  void await_suspend(handle_type) noexcept {}
+  [[nodiscard]] int await_resume() noexcept { return 1; }
+};
+
+template <class Await>
+struct check_warning_promise {
+  coro<check_warning_promise> get_return_object();
+  Await initial_suspend();
+  Await final_suspend() noexcept;
+  Await yield_value(int);
+  void return_void();
+  void unhandled_exception();
+};
+
+coro<check_warning_promise<awaitable_no_unused_warn>>
+test_no_unused_warning() {
+  co_await awaitable_no_unused_warn();
+  co_yield 42;
+}
+
+coro<check_warning_promise<awaitable_unused_warn>>
+test_unused_warning() {
+  co_await awaitable_unused_warn(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  co_yield 42;                      // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
+
+struct missing_await_ready {
+  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_resume();
+};
+struct missing_await_suspend {
+  bool await_ready();
+  void await_resume();
+};
+struct missing_await_resume {
+  bool await_ready();
+  void await_suspend(std::experimental::coroutine_handle<>);
+};
+
+void test_missing_awaitable_members() {
+  co_await missing_await_ready{};   // expected-error {{no member named 'await_ready' in 'missing_await_ready'}}
+  co_await missing_await_suspend{}; // expected-error {{no member named 'await_suspend' in 'missing_await_suspend'}}
+  co_await missing_await_resume{};  // expected-error {{no member named 'await_resume' in 'missing_await_resume'}}
+}

clang/test/SemaCXX/coroutines.cpp

 // This file contains references to sections of the Coroutines TS, which can be
 // found at http://wg21.link/coroutines.
 
 // RUN: %clang_cc1 -std=c++2b                 -fsyntax-only -verify=expected,cxx20_2b,cxx2b    %s -fcxx-exceptions -fexceptions -Wunused-result
 // RUN: %clang_cc1 -std=c++20                 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result
 // RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -fsyntax-only -verify=expected,cxx14_20          %s -fcxx-exceptions -fexceptions -Wunused-result
 
 void no_coroutine_traits_bad_arg_await() {
-  co_await a; // expected-error {{include <experimental/coroutine>}}
+  co_await a; // expected-error {{include <coroutine>}}
   // expected-error@-1 {{use of undeclared identifier 'a'}}
 }
 
 void no_coroutine_traits_bad_arg_yield() {
-  co_yield a; // expected-error {{include <experimental/coroutine>}}
+  co_yield a; // expected-error {{include <coroutine>}}
   // expected-error@-1 {{use of undeclared identifier 'a'}}
 }
 
 
 void no_coroutine_traits_bad_arg_return() {
-  co_return a; // expected-error {{include <experimental/coroutine>}}
+  co_return a; // expected-error {{include <coroutine>}}
   // expected-error@-1 {{use of undeclared identifier 'a'}}
 }
 
 void no_coroutine_traits() {
-  co_await 4; // expected-error {{std::experimental::coroutine_traits type was not found; include <experimental/coroutine>}}
+  co_await 4; // expected-error {{std::coroutine_traits type was not found; include <coroutine>}}
 }
 
 namespace std {
-namespace experimental {
 
 template <class... Args>
 struct void_t_imp {
   using type = void;
 };
 template <class... Args>
 using void_t = typename void_t_imp<Args...>::type;
 
 template <class T, class = void>
 struct traits_sfinae_base {};
 
 template <class T>
 struct traits_sfinae_base<T, void_t<typename T::promise_type>> {
   using promise_type = typename T::promise_type;
 };
 
 template <class Ret, class... Args>
 struct coroutine_traits : public traits_sfinae_base<Ret> {};
-}}  // namespace std::experimental
+} // end of namespace std
 
 template<typename Promise> struct coro {};
 template <typename Promise, typename... Ps>
-struct std::experimental::coroutine_traits<coro<Promise>, Ps...> {
+struct std::coroutine_traits<coro<Promise>, Ps...> {
   using promise_type = Promise;
 };
 
 struct awaitable {
   bool await_ready() noexcept;
   template <typename F>
   void await_suspend(F) noexcept;
   void await_resume() noexcept;

 
 struct auto_await_suspend {
   bool await_ready();
   template <typename F> auto await_suspend(F) {}
   void await_resume();
 };
 
 struct DummyVoidTag {};
-DummyVoidTag no_specialization() { // expected-error {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<DummyVoidTag>' has no member named 'promise_type'}}
+DummyVoidTag no_specialization() { // expected-error {{this function cannot be a coroutine: 'std::coroutine_traits<DummyVoidTag>' has no member named 'promise_type'}}
   co_await a;
 }
 
 template <typename... T>
-struct std::experimental::coroutine_traits<int, T...> {};
+struct std::coroutine_traits<int, T...> {};
 
-int no_promise_type() { // expected-error {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<int>' has no member named 'promise_type'}}
+int no_promise_type() { // expected-error {{this function cannot be a coroutine: 'std::coroutine_traits<int>' has no member named 'promise_type'}}
   co_await a;
 }
 
-int no_promise_type_multiple_awaits(int) { // expected-error {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<int, int>' has no member named 'promise_type'}}
+int no_promise_type_multiple_awaits(int) { // expected-error {{this function cannot be a coroutine: 'std::coroutine_traits<int, int>' has no member named 'promise_type'}}
   co_await a;
   co_await a;
 }
 
 template <>
-struct std::experimental::coroutine_traits<double, double> { typedef int promise_type; };
-double bad_promise_type(double) { // expected-error {{this function cannot be a coroutine: 'experimental::coroutine_traits<double, double>::promise_type' (aka 'int') is not a class}}
+struct std::coroutine_traits<double, double> { typedef int promise_type; };
+double bad_promise_type(double) { // expected-error {{this function cannot be a coroutine: 'std::coroutine_traits<double, double>::promise_type' (aka 'int') is not a class}}
   co_await a;
 }
 
 template <>
-struct std::experimental::coroutine_traits<double, int> {
+struct std::coroutine_traits<double, int> {
   struct promise_type {};
 };
 double bad_promise_type_2(int) { // expected-error {{no member named 'initial_suspend'}}
-  co_yield 0; // expected-error {{no member named 'yield_value' in 'std::experimental::coroutine_traits<double, int>::promise_type'}}
+  co_yield 0;                    // expected-error {{no member named 'yield_value' in 'std::coroutine_traits<double, int>::promise_type'}}
 }
 
 struct promise; // expected-note {{forward declaration}}
 struct promise_void;
 struct void_tag {};
 template <typename... T>
-struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise; };
+struct std::coroutine_traits<void, T...> { using promise_type = promise; };
 template <typename... T>
-struct std::experimental::coroutine_traits<void, void_tag, T...>
-{ using promise_type = promise_void; };
+struct std::coroutine_traits<void, void_tag, T...> { using promise_type = promise_void; };
 
 // FIXME: This diagnostic is terrible.
-void undefined_promise() { // expected-error {{this function cannot be a coroutine: 'experimental::coroutine_traits<void>::promise_type' (aka 'promise') is an incomplete type}}
+void undefined_promise() { // expected-error {{this function cannot be a coroutine: 'std::coroutine_traits<void>::promise_type' (aka 'promise') is an incomplete type}}
   co_await a;
 }
 
 struct yielded_thing { const char *p; short a, b; };
 
 struct not_awaitable {};
 
 struct promise {

 struct promise_void {
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_void();
   void unhandled_exception();
 };
 
-void no_coroutine_handle() { // expected-error {{std::experimental::coroutine_handle type was not found; include <experimental/coroutine> before defining a coroutine}}
+void no_coroutine_handle() { // expected-error {{std::coroutine_handle type was not found; include <coroutine> before defining a coroutine}}
   //expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
   co_return 5; //expected-note {{function is a coroutine due to use of 'co_return' here}}
 }
 
 namespace std {
-namespace experimental {
 template <class PromiseType = void>
 struct coroutine_handle {
   static coroutine_handle from_address(void *) noexcept;
 };
 template <>
 struct coroutine_handle<void> {
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
   static coroutine_handle from_address(void *) noexcept;
 };
-}} // namespace std::experimental
+} // namespace std
 
 void yield() {
   co_yield 0;
   co_yield {"foo", 1, 2};
   co_yield {1e100}; // expected-error {{cannot be narrowed}} expected-note {{explicit cast}} expected-warning {{implicit conversion}} expected-warning {{braces around scalar}}
   co_yield {"foo", __LONG_LONG_MAX__}; // expected-error {{cannot be narrowed}} expected-note {{explicit cast}} expected-warning {{changes value}}
   co_yield {"foo"};
   co_yield "foo"; // expected-error {{no matching}}
namespace dependent_operator_co_await_lookup {
 
   template coro<transform_promise> await_template_3<transform_promise>(transform_awaitable);
   template struct dependent_member<transform_promise>;
   template coro<transform_promise> dependent_member<transform_promise>::dep_mem_fn(transform_awaitable);
 }
 
 struct yield_fn_tag {};
 template <>
-struct std::experimental::coroutine_traits<void, yield_fn_tag> {
+struct std::coroutine_traits<void, yield_fn_tag> {
   struct promise_type {
     // FIXME: add an await_transform overload for functions
     awaitable yield_value(int());
     void return_value(int());
 
     suspend_never initial_suspend();
     suspend_never final_suspend() noexcept;
     void get_return_object();
[](auto &arg) ->coro<good_promise_1> { // expected-warning {{expression result unused}}
     []() -> coro<good_promise_1> {
       co_await 36;
     };
     co_await 48;
   };
 }
 template void ok_generic_lambda_coawait_PR41909<int>(); // expected-note {{in instantiation of function template specialization 'ok_generic_lambda_coawait_PR41909<int>' requested here}}
 
-template<> struct std::experimental::coroutine_traits<int, int, const char**>
-{ using promise_type = promise; };
+template <> struct std::coroutine_traits<int, int, const char **> { using promise_type = promise; };
 
 int main(int, const char**) {
   co_await a; // expected-error {{'co_await' cannot be used in the 'main' function}}
 }
 
 struct good_promise_2 {
   float get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_void();
   void unhandled_exception();
 };
-template<> struct std::experimental::coroutine_handle<good_promise_2> {};
+template <> struct std::coroutine_handle<good_promise_2> {};
 
-template<> struct std::experimental::coroutine_traits<float>
-{ using promise_type = good_promise_2; };
+template <> struct std::coroutine_traits<float> { using promise_type = good_promise_2; };
 
-float badly_specialized_coro_handle() { // expected-error {{std::experimental::coroutine_handle missing a member named 'from_address'}}
+float badly_specialized_coro_handle() { // expected-error {{std::coroutine_handle missing a member named 'from_address'}}
   //expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
   co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
 }
 
 namespace std {
   struct nothrow_t {};
   constexpr nothrow_t nothrow = {};
 }
 
 using SizeT = decltype(sizeof(int));
 
 void* operator new(SizeT __sz, const std::nothrow_t&) noexcept;
 void  operator delete(void* __p, const std::nothrow_t&) noexcept;
 
 
 
 struct promise_on_alloc_failure_tag {};
 
-template<>
-struct std::experimental::coroutine_traits<int, promise_on_alloc_failure_tag> {
+template <>
+struct std::coroutine_traits<int, promise_on_alloc_failure_tag> {
   struct promise_type {
     int get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     int get_return_object_on_allocation_failure(); // expected-error{{'promise_type': 'get_return_object_on_allocation_failure()' must be a static member function}}
     void unhandled_exception();
   };

 };
 
 coro<good_promise_noexcept_custom_new_operator>
 good_coroutine_calls_noexcept_custom_new_operator(double, float, int) {
   co_return;
 }
 
 struct mismatch_gro_type_tag1 {};
-template<>
-struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag1> {
+template <>
+struct std::coroutine_traits<int, mismatch_gro_type_tag1> {
   struct promise_type {
     void get_return_object() {} //expected-note {{member 'get_return_object' declared here}}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception();
   };
 };
 
 extern "C" int f(mismatch_gro_type_tag1) {
   // expected-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void'}}
   co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
 }
 
 struct mismatch_gro_type_tag2 {};
-template<>
-struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag2> {
+template <>
+struct std::coroutine_traits<int, mismatch_gro_type_tag2> {
   struct promise_type {
     void *get_return_object() {} //expected-note {{member 'get_return_object' declared here}}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception();
   };
 };
 
 extern "C" int f(mismatch_gro_type_tag2) {
   // cxx2b-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void *'}}
   // cxx14_20-error@-2 {{cannot initialize return object of type 'int' with an lvalue of type 'void *'}}
   co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
 }
 
 struct mismatch_gro_type_tag3 {};
-template<>
-struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag3> {
+template <>
+struct std::coroutine_traits<int, mismatch_gro_type_tag3> {
   struct promise_type {
     int get_return_object() {}
     static void get_return_object_on_allocation_failure() {} //expected-note {{member 'get_return_object_on_allocation_failure' declared here}}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception();
   };
 };
 
 extern "C" int f(mismatch_gro_type_tag3) {
   // expected-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void'}}
   co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
 }
 
 
 struct mismatch_gro_type_tag4 {};
-template<>
-struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag4> {
+template <>
+struct std::coroutine_traits<int, mismatch_gro_type_tag4> {
   struct promise_type {
     int get_return_object() {}
     static char *get_return_object_on_allocation_failure() {} //expected-note {{member 'get_return_object_on_allocation_failure' declared}}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception();
   };

 coro<bad_promise_no_return_func> no_return_value_or_return_void() {
   // expected-error@-1 {{'bad_promise_no_return_func' must declare either 'return_value' or 'return_void'}}
   co_await a;
 }
 
 struct bad_await_suspend_return {
   bool await_ready();
   // expected-error@+1 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'char')}}
-  char await_suspend(std::experimental::coroutine_handle<>);
+  char await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 struct bad_await_ready_return {
   // expected-note@+1 {{return type of 'await_ready' is required to be contextually convertible to 'bool'}}
   void await_ready();
-  bool await_suspend(std::experimental::coroutine_handle<>);
+  bool await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 struct await_ready_explicit_bool {
   struct BoolT {
     explicit operator bool() const;
   };
   BoolT await_ready();
-  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 template <class SuspendTy>
 struct await_suspend_type_test {
   bool await_ready();
   // expected-error@+2 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &')}}
   // expected-error@+1 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &&')}}
-  SuspendTy await_suspend(std::experimental::coroutine_handle<>);
+  SuspendTy await_suspend(std::coroutine_handle<>);
   // cxx20_2b-warning@-1 {{volatile-qualified return type 'const volatile bool' is deprecated}}
   void await_resume();
 };
 void test_bad_suspend() {
   {
     // FIXME: The actual error emitted here is terrible, and no number of notes can save it.
     bad_await_ready_return a;
     // expected-error@+1 {{value of type 'void' is not contextually convertible to 'bool'}}

 
 template <class T>
 struct TypeTest {
   template <class U>
   static constexpr bool IsSame = IsSameV<T, U>;
 
   template <class... Args>
   static constexpr bool MatchesArgs = IsSameV<T,
-                                              std::experimental::coroutine_traits<CoroMemberTag, Args...>>;
+                                              std::coroutine_traits<CoroMemberTag, Args...>>;
 };
 
 template <class T>
 struct AwaitReturnsType {
   bool await_ready() const;
   void await_suspend(...) const;
   T await_resume() const;
 };
 
 template <class... CoroTraitsArgs>
 struct CoroMemberPromise {
-  using TraitsT = std::experimental::coroutine_traits<CoroTraitsArgs...>;
+  using TraitsT = std::coroutine_traits<CoroTraitsArgs...>;
   using TypeTestT = TypeTest<TraitsT>;
   using AwaitTestT = AwaitReturnsType<TypeTestT>;
 
   CoroMemberTag get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
 
   AwaitTestT yield_value(int);
 
   void return_void();
   void unhandled_exception();
 };
 
 } // namespace CoroHandleMemberFunctionTest
 
 template <class... Args>
-struct ::std::experimental::coroutine_traits<CoroHandleMemberFunctionTest::CoroMemberTag, Args...> {
+struct ::std::coroutine_traits<CoroHandleMemberFunctionTest::CoroMemberTag, Args...> {
   using promise_type = CoroHandleMemberFunctionTest::CoroMemberPromise<CoroHandleMemberFunctionTest::CoroMemberTag, Args...>;
 };
 
 namespace CoroHandleMemberFunctionTest {
 struct TestType {
 
   CoroMemberTag test_qual() {
     auto TC = co_yield 0;
struct TestType {
   static CoroMemberTag test_static_template(const char *volatile &, unsigned) {
     auto TC = co_yield 0;
     using TCT = decltype(TC);
     static_assert(TCT::MatchesArgs<const char *volatile &, unsigned>, "");
     static_assert(!TCT::MatchesArgs<TestType &, const char *volatile &, unsigned>, "");
   }
 
   BadCoroMemberTag test_diagnostics() {
-    // expected-error@-1 {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, CoroHandleMemberFunctionTest::TestType &>' has no member named 'promise_type'}}
+    // expected-error@-1 {{this function cannot be a coroutine: 'std::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, CoroHandleMemberFunctionTest::TestType &>' has no member named 'promise_type'}}
     co_return;
   }
   BadCoroMemberTag test_diagnostics(int) const && {
-    // expected-error@-1 {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, const CoroHandleMemberFunctionTest::TestType &&, int>' has no member named 'promise_type'}}
+    // expected-error@-1 {{this function cannot be a coroutine: 'std::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, const CoroHandleMemberFunctionTest::TestType &&, int>' has no member named 'promise_type'}}
     co_return;
   }
 
   static BadCoroMemberTag test_static_diagnostics(long *) {
-    // expected-error@-1 {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, long *>' has no member named 'promise_type'}}
+    // expected-error@-1 {{this function cannot be a coroutine: 'std::coroutine_traits<CoroHandleMemberFunctionTest::BadCoroMemberTag, long *>' has no member named 'promise_type'}}
     co_return;
   }
 };
 
 template CoroMemberTag TestType::test_member_template(long, const char *) const &&;
 template CoroMemberTag TestType::test_static_template<void>(const char *volatile &, unsigned);
 
 template <class... Args>
struct bad_promise_deleted_constructor {
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_void();
   void unhandled_exception();
 };
 
 coro<bad_promise_deleted_constructor>
 bad_coroutine_calls_deleted_promise_constructor() {
-  // expected-error@-1 {{call to deleted constructor of 'std::experimental::coroutine_traits<coro<CoroHandleMemberFunctionTest::bad_promise_deleted_constructor>>::promise_type' (aka 'CoroHandleMemberFunctionTest::bad_promise_deleted_constructor')}}
+  // expected-error@-1 {{call to deleted constructor of 'std::coroutine_traits<coro<CoroHandleMemberFunctionTest::bad_promise_deleted_constructor>>::promise_type' (aka 'CoroHandleMemberFunctionTest::bad_promise_deleted_constructor')}}
   co_return;
 }
 
 // Test that, when the promise type has a constructor whose signature matches
 // that of the coroutine function, that constructor is used. If no matching
 // constructor exists, the default constructor is used as a fallback. If no
 // matching constructors exist at all, an error is emitted. This is an
 // experimental feature that will be proposed for the Coroutines TS.
struct bad_promise_no_matching_constructor {
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_void();
   void unhandled_exception();
 };
 
 coro<bad_promise_no_matching_constructor>
 bad_coroutine_calls_with_no_matching_constructor(int, int) {
-  // expected-error@-1 {{call to deleted constructor of 'std::experimental::coroutine_traits<coro<CoroHandleMemberFunctionTest::bad_promise_no_matching_constructor>, int, int>::promise_type' (aka 'CoroHandleMemberFunctionTest::bad_promise_no_matching_constructor')}}
+  // expected-error@-1 {{call to deleted constructor of 'std::coroutine_traits<coro<CoroHandleMemberFunctionTest::bad_promise_no_matching_constructor>, int, int>::promise_type' (aka 'CoroHandleMemberFunctionTest::bad_promise_no_matching_constructor')}}
   co_return;
 }
 
 struct some_class2 {
 coro<bad_promise_no_matching_constructor>
 bad_coroutine_calls_with_no_matching_constructor(int, int, int) {
   // expected-error@-1 {{call to deleted constructor}}
   co_return;
 }
 };
 
 } // namespace CoroHandleMemberFunctionTest
 
 class awaitable_no_unused_warn {
 public:
-  using handle_type = std::experimental::coroutine_handle<>;
+  using handle_type = std::coroutine_handle<>;
   constexpr bool await_ready() noexcept { return false; }
   void await_suspend(handle_type) noexcept {}
   int await_resume() noexcept { return 1; }
 };
 
 
 class awaitable_unused_warn {
 public:
-  using handle_type = std::experimental::coroutine_handle<>;
+  using handle_type = std::coroutine_handle<>;
   constexpr bool await_ready() noexcept { return false; }
   void await_suspend(handle_type) noexcept {}
   [[nodiscard]] int await_resume() noexcept { return 1; }
 };
 
 template <class Await>
 struct check_warning_promise {
   coro<check_warning_promise> get_return_object();

 
 coro<check_warning_promise<awaitable_unused_warn>>
 test_unused_warning() {
   co_await awaitable_unused_warn(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
   co_yield 42; // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 }
 
 struct missing_await_ready {
-  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 struct missing_await_suspend {
   bool await_ready();
   void await_resume();
 };
 struct missing_await_resume {
   bool await_ready();
-  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_suspend(std::coroutine_handle<>);
 };
 
 void test_missing_awaitable_members() {
   co_await missing_await_ready{}; // expected-error {{no member named 'await_ready' in 'missing_await_ready'}}
   co_await missing_await_suspend{}; // expected-error {{no member named 'await_suspend' in 'missing_await_suspend'}}
   co_await missing_await_resume{}; // expected-error {{no member named 'await_resume' in 'missing_await_resume'}}
 }

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

EXPECT_TRUE(matches(
                               hasAncestor(lambdaExpr(hasAncestor(
                                   varDecl(hasName("lPtrDecay"))))))));
 }
 
 TEST(Matcher, MatchesCoroutine) {
   FileContentMappings M;
   M.push_back(std::make_pair("/coro_header", R"cpp(
 namespace std {
-namespace experimental {
 
 template <class... Args>
 struct void_t_imp {
   using type = void;
 };
 template <class... Args>
 using void_t = typename void_t_imp<Args...>::type;
 
 template <class T, class = void>
 struct traits_sfinae_base {};
 
 template <class T>
 struct traits_sfinae_base<T, void_t<typename T::promise_type>> {
   using promise_type = typename T::promise_type;
 };
 
 template <class Ret, class... Args>
 struct coroutine_traits : public traits_sfinae_base<Ret> {};
-}}  // namespace std::experimental
+}  // namespace std
 struct awaitable {
   bool await_ready() noexcept;
   template <typename F>
   void await_suspend(F) noexcept;
   void await_resume() noexcept;
 } a;
 struct promise {
   void get_return_object();
   awaitable initial_suspend();
   awaitable final_suspend() noexcept;
   awaitable yield_value(int); // expected-note 2{{candidate}}
   void return_value(int); // expected-note 2{{here}}
   void unhandled_exception();
 };
 template <typename... T>
-struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise; };
+struct std::coroutine_traits<void, T...> { using promise_type = promise; };
 namespace std {
-namespace experimental {
 template <class PromiseType = void>
 struct coroutine_handle {
   static coroutine_handle from_address(void *) noexcept;
 };
-}} // namespace std::experimental
+} // namespace std
 )cpp"));
   StringRef CoReturnCode = R"cpp(
 #include <coro_header>
 void check_match_co_return() {
   co_return 1;
 }
 )cpp";
   EXPECT_TRUE(matchesConditionally(CoReturnCode,