[Coroutines] [libcxx] Move coroutine component out of experimental namespace

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

To make clang compatible with legacy uses, the use of coroutine in std::experimental namespace is remained.

Test Plan: check-all

[ChuanqiXu]

fix tests in clang-tools-extra.

[ChuanqiXu]

Fix lint

[lxfind]

I am not familiar with the process of when to move something out of experimental, but I do wonder how this is normally done so that people who uses coroutines can have a smooth migration?
I assume that this is going to be a breaking change that existing code using coroutine will need to be updated and no longer compatible with old versions.

[ChuanqiXu]

• Make clang support looking up in std::experimental namespace.

[ChuanqiXu]

In D108615#2962618, @lxfind wrote:

I am not familiar with the process of when to move something out of experimental, but I do wonder how this is normally done so that people who uses coroutines can have a smooth migration?
I assume that this is going to be a breaking change that existing code using coroutine will need to be updated and no longer compatible with old versions.

Thanks for reporting this. Now the clang could still look up in std::experimental namespace of once it fails to look up in std namespace. So now it wouldn't be a break change if the user upgrade the version clang only.

[ChuanqiXu]

Fix test: libcxx/utils/generate_header_tests.py

[ChuanqiXu]

Oh, I find why the CI still fails. Since the compiler used to compile libcxx in the CI doesn't contain the change in this patch! So it would still lookup coroutine components in std::experimental namespace. So here are the failures. To avoid the problems, I had split this patch into D108696 and D108697, which contains the change in clang part and libcxx part respectively.

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 "
+  "%0 type was not found; include <coroutine> before defining "
   "a coroutine">;
 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 "

clang/include/clang/Sema/Sema.h

Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
                                SourceLocation LBrace,
                                const ParsedAttributesView &AttrList,
                                UsingDirectiveDecl *&UsingDecl);
   void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
 
   NamespaceDecl *getStdNamespace() const;
   NamespaceDecl *getOrCreateStdNamespace();
 
-  NamespaceDecl *lookupStdExperimentalNamespace();
-
   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.
   llvm::SmallBitVector FullyCheckedComparisonCategories;

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) {
+  NamespaceDecl *Std = S.getStdNamespace();
+  if (!Std) {
     S.Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
-        << "std::experimental::coroutine_traits";
+        << "std::coroutine_traits";
     return QualType();
   }
 
   ClassTemplateDecl *CoroTraits = S.lookupCoroutineTraits(KwLoc, FuncLoc);
   if (!CoroTraits) {
     return QualType();
   }
 
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, Std);
     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 *Std = S.getStdNamespace();
+  assert(Std && "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, Std)) {
     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) {
   if (!Res)
     return StmtError();
   return Res;
 }
 
 ClassTemplateDecl *Sema::lookupCoroutineTraits(SourceLocation KwLoc,
                                                SourceLocation FuncLoc) {
   if (!StdCoroutineTraitsCache) {
-    if (auto StdExp = lookupStdExperimentalNamespace()) {
+    if (auto Std = getStdNamespace()) {
       LookupResult Result(*this,
                           &PP.getIdentifierTable().get("coroutine_traits"),
                           FuncLoc, LookupOrdinaryName);
-      if (!LookupQualifiedName(Result, StdExp)) {
+      if (!LookupQualifiedName(Result, Std)) {
         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;
       }
     }
   }
   return StdCoroutineTraitsCache;
 }

clang/lib/Sema/SemaDeclCXX.cpp

   return cast_or_null<EnumDecl>(StdAlignValT.get(Context.getExternalSource()));
 }
 
 NamespaceDecl *Sema::getStdNamespace() const {
   return cast_or_null<NamespaceDecl>(
                                  StdNamespace.get(Context.getExternalSource()));
 }
 
-NamespaceDecl *Sema::lookupStdExperimentalNamespace() {
-  if (!StdExperimentalNamespaceCache) {
-    if (auto Std = getStdNamespace()) {
-      LookupResult Result(*this, &PP.getIdentifierTable().get("experimental"),
-                          SourceLocation(), LookupNamespaceName);
-      if (!LookupQualifiedName(Result, Std) ||
-          !(StdExperimentalNamespaceCache =
-                Result.getAsSingle<NamespaceDecl>()))
-        Result.suppressDiagnostics();
-    }
-  }
-  return StdExperimentalNamespaceCache;
-}
-
 namespace {
 
 enum UnsupportedSTLSelect {
   USS_InvalidMember,
   USS_MissingMember,
   USS_NonTrivial,
   USS_Other
 };

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.
 // PR42867: Disable this test for the new PM since the passes that lower the
 // llvm.coro.* intrinsics have not yet been ported.
 // RUN: %clang_cc1 -fno-experimental-new-pass-manager -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"* nonnull align 8 dereferenceable(8) %[[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.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.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.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.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.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.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.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.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.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.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-addres-return-type.cpp

 // RUN: %clang_cc1 -verify %s -stdlib=libc++ -std=c++1z -fcoroutines-ts -fsyntax-only
 
-namespace std::experimental {
+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 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 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 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::experimental {
+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::experimental
+} // namespace std
 
 struct awaitable {
   bool await_ready();
 
-  std::experimental::coroutine_handle<task::promise_type>
-  await_suspend(std::experimental::coroutine_handle<> handle);
+  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.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, 

libcxx/CMakeLists.txt

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

libcxx/include/CMakeLists.txt

set(files
   clocale
   cmath
   codecvt
   compare
   complex
   complex.h
   concepts
   condition_variable
+  coroutine
   csetjmp
   csignal
   cstdarg
   cstdbool
   cstddef
   cstdint
   cstdio
   cstdlib
   cstring
   ctgmath
   ctime
   ctype.h
   cwchar
   cwctype
   deque
   errno.h
   exception
   execution
   experimental/__config
   experimental/__memory
   experimental/algorithm
-  experimental/coroutine
   experimental/deque
   experimental/filesystem
   experimental/forward_list
   experimental/functional
   experimental/iterator
   experimental/list
   experimental/map
   experimental/memory_resource

libcxx/include/coroutine

 // -*- C++ -*-
 //===----------------------------- coroutine -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP_EXPERIMENTAL_COROUTINE
-#define _LIBCPP_EXPERIMENTAL_COROUTINE
+#ifndef _LIBCPP_COROUTINE
+#define _LIBCPP_COROUTINE
 
 /**
-    experimental/coroutine synopsis
+    coroutine synopsis
 
 // C++next
 
 namespace std {
-namespace experimental {
-inline namespace coroutines_v1 {
 
   // 18.11.1 coroutine traits
 template <typename R, typename... ArgTypes>
 class coroutine_traits;
 // 18.11.2 coroutine handle
 template <typename Promise = void>
 class coroutine_handle;
 // 18.11.2.7 comparison operators:
 bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
 bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
 bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
 bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
 bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
 bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
 // 18.11.3 trivial awaitables
 struct suspend_never;
 struct suspend_always;
 // 18.11.2.8 hash support:
 template <class T> struct hash;
 template <class P> struct hash<coroutine_handle<P>>;
 
-} // namespace coroutines_v1
-} // namespace experimental
 } // namespace std
 
  */
 
-#include <experimental/__config>
+#include <__config>
 #include <new>
 #include <type_traits>
 #include <functional>
 #include <memory> // for hash<T*>
 #include <cstddef>
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_COROUTINES
 # if defined(_LIBCPP_WARNING)
-    _LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler")
+    _LIBCPP_WARNING("<coroutine> cannot be used with this compiler")
 # else
-#   warning <experimental/coroutine> cannot be used with this compiler
+#   warning <coroutine> cannot be used with this compiler
 # endif
 #endif
 
 #ifndef _LIBCPP_HAS_NO_COROUTINES
 
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
+_LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class = void>
 struct __coroutine_traits_sfinae {};
 
 template <class _Tp>
 struct __coroutine_traits_sfinae<
     _Tp, typename __void_t<typename _Tp::promise_type>::type>
 {
struct suspend_always {
   _LIBCPP_INLINE_VISIBILITY
   bool await_ready() const _NOEXCEPT { return false; }
   _LIBCPP_INLINE_VISIBILITY
   void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
   _LIBCPP_INLINE_VISIBILITY
   void await_resume() const _NOEXCEPT {}
 };
 
-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
 template <class _Tp>
-struct hash<_VSTD_CORO::coroutine_handle<_Tp> > {
-    using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>;
+struct hash<_VSTD::coroutine_handle<_Tp> > {
+    using __arg_type = _VSTD::coroutine_handle<_Tp>;
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(__arg_type const& __v) const _NOEXCEPT
     {return hash<void*>()(__v.address());}
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !defined(_LIBCPP_HAS_NO_COROUTINES)
 
-#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */
+#endif /* _LIBCPP_COROUTINE */

libcxx/include/experimental/__config

 
 #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
     _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM { \
     inline namespace v1 {
 
 #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
     } } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
-#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \
-  _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 {
-
-#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES \
-  } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
-
-#define _VSTD_CORO _VSTD_EXPERIMENTAL::coroutines_v1
-
 #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \
     _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 {
 
 #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD \
     } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
     _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi {

libcxx/include/module.modulemap

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

libcxx/test/libcxx/double_include.sh.cpp

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

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: fcoroutines-ts
 // ADDITIONAL_COMPILE_FLAGS: -fcoroutines-ts
 
-// A simple "breathing" test that checks that <experimental/coroutine>
+// A simple "breathing" test that checks that <coroutine>
 // can be parsed and used in all dialects, including C++03 in order to match
 // Clang's behavior.
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental::coroutines_v1;
-
-coro::suspend_always sa;
-coro::suspend_never sn;
+std::suspend_always sa;
+std::suspend_never sn;
 
 struct MyFuture {
   struct promise_type {
-    typedef coro::coroutine_handle<promise_type> HandleT;
-    coro::suspend_never initial_suspend() { return sn; }
-    coro::suspend_always final_suspend() TEST_NOEXCEPT { return sa; }
-    coro::suspend_never yield_value(int) { return sn; }
+    typedef std::coroutine_handle<promise_type> HandleT;
+    std::suspend_never initial_suspend() { return sn; }
+    std::suspend_always final_suspend() TEST_NOEXCEPT { return sa; }
+    std::suspend_never yield_value(int) { return sn; }
     MyFuture get_return_object() {
       MyFuture f(HandleT::from_promise(*this));
       return f;
     }
     void return_void() {}
     void unhandled_exception() {}
   };
   typedef promise_type::HandleT HandleT;
   MyFuture() : p() {}
   MyFuture(HandleT h) : p(h) {}
 
-  coro::coroutine_handle<promise_type> p;
+  std::coroutine_handle<promise_type> p;
 };
 
 MyFuture test_coro() {
   co_await sn;
   co_yield 42;
   co_return;
 }
 

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // REQUIRES: fcoroutines-ts
 // ADDITIONAL_COMPILE_FLAGS: -fcoroutines-ts
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION must be defined
 #endif
 
 int main(int, char**)
 {
 
   return 0;
 }

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

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

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

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

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // namespace std {
-//  template <class P> struct hash<experimental::coroutine_handle<P>>;
+//  template <class P> struct hash<coroutine_handle<P>>;
 // }
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   const size_t ExpectLHS = std::hash<void*>{}(reinterpret_cast<void*>(LHSVal));
   const size_t ExpectRHS = std::hash<void*>{}(reinterpret_cast<void*>(RHSVal));
   const C LHS = C::from_address(reinterpret_cast<void*>(LHSVal));
   const C RHS = C::from_address(reinterpret_cast<void*>(RHSVal));
   const std::hash<C> h;
   // FIXME: libc++'s implementation hash's the result of LHS.address(), so we

 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
       {0, 8},
       {8, 8},
       {8, 16}
   };
   for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
+    do_test<std::coroutine_handle<> >(TC.first, TC.second);
+    do_test<std::coroutine_handle<int> >(TC.first, TC.second);
   }
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr explicit operator bool() const noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   static_assert(std::is_nothrow_constructible<bool, C>::value, "");
   static_assert(!std::is_convertible<C, bool>::value, "");
   {
     constexpr C c; ((void)c);
     static_assert(bool(c) == false, "");
   }
static_assert(!std::is_convertible<C, bool>::value, "");
     C c = C::from_address((void*)&dummy);
     assert(c.address() == &dummy);
     assert(bool(c) == true);
   }
 }
 
 int main(int, char**)
 {
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // bool operator==(coroutine_handle<>, coroutine_handle<>) noexcept
 // bool operator!=(coroutine_handle<>, coroutine_handle<>) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   const C LHS = C::from_address(reinterpret_cast<void*>(LHSVal));
   const C RHS = C::from_address(reinterpret_cast<void*>(RHSVal));
   const bool ExpectIsEqual = (LHSVal == RHSVal);
   assert((LHS == RHS) == ExpectIsEqual);
   assert((RHS == LHS) == ExpectIsEqual);
   assert((LHS != RHS) == !ExpectIsEqual);

 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
       {16, 16},
       {0, 16},
       {16, 0}
   };
   for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
+    do_test<std::coroutine_handle<> >(TC.first, TC.second);
+    do_test<std::coroutine_handle<int> >(TC.first, TC.second);
   }
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // bool operator<(coroutine_handle<>, coroutine_handle<>) noexcept
 // bool operator>(coroutine_handle<>, coroutine_handle<>) noexcept
 // bool operator>=(coroutine_handle<>, coroutine_handle<>) noexcept
 // bool operator<=(coroutine_handle<>, coroutine_handle<>) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   const C LHS = C::from_address(reinterpret_cast<void*>(LHSVal));
   const C RHS = C::from_address(reinterpret_cast<void*>(RHSVal));
   assert((LHS < RHS) == (LHSVal < RHSVal));
   assert((RHS < LHS) == (RHSVal < LHSVal));
   assert((LHS > RHS) == (LHSVal > RHSVal));
   assert((RHS > LHS) == (RHSVal > LHSVal));

 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
       {16, 16},
       {0, 16},
       {16, 0}
   };
   for (auto& TC : TestCases) {
-    do_test<coro::coroutine_handle<>>(TC.first, TC.second);
-    do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
+    do_test<std::coroutine_handle<> >(TC.first, TC.second);
+    do_test<std::coroutine_handle<int> >(TC.first, TC.second);
   }
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // bool done() const
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class Promise>
-void do_test(coro::coroutine_handle<Promise> const& H) {
+void do_test(std::coroutine_handle<Promise> const& H) {
   // FIXME Add a runtime test
   {
     ASSERT_SAME_TYPE(decltype(H.done()), bool);
     LIBCPP_ASSERT_NOT_NOEXCEPT(H.done());
   }
 }
 
 int main(int, char**)
 {
-  do_test(coro::coroutine_handle<>{});
-  do_test(coro::coroutine_handle<int>{});
+  do_test(std::coroutine_handle<>{});
+  do_test(std::coroutine_handle<int>{});
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // coroutine_handle& operator=(nullptr_t) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   int dummy = 42;
   void* dummy_h = &dummy;
   {
     C c; ((void)c);
     static_assert(std::is_nothrow_assignable<C&, std::nullptr_t>::value, "");
     static_assert(!std::is_assignable<C&, void*>::value, "");
void* dummy_h = &dummy;
     C c;
     C& cr = (c = nullptr);
     assert(&c == &cr);
   }
 }
 
 int main(int, char**)
 {
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr coroutine_handle() noexcept
 // constexpr coroutine_handle(nullptr_t) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   {
     constexpr C c;
     static_assert(std::is_nothrow_default_constructible<C>::value, "");
     static_assert(c.address() == nullptr, "");
   }
   {
     constexpr C c(nullptr);
     static_assert(std::is_nothrow_constructible<C, std::nullptr_t>::value, "");
     static_assert(c.address() == nullptr, "");
   }
   {
     C c;
     assert(c.address() == nullptr);
   }
   {
     C c(nullptr);
     assert(c.address() == nullptr);
   }
 }
 
 int main(int, char**)
 {
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr void* address() const noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   {
     constexpr C c; ((void)c);
     static_assert(c.address() == nullptr, "");
   }
   {
     const C c = {}; ((void)c);
     ASSERT_NOEXCEPT(c.address());
     ASSERT_SAME_TYPE(decltype(c.address()), void*);
     assert(c.address() == nullptr);
   }
   {
     char dummy = 42;
     C c = C::from_address((void*)&dummy);
     assert(c.address() == &dummy);
   }
 }
 
 int main(int, char**)
 {
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // static coroutine_handle from_address(void*) noexcept
 
 // Test that `from_address` is explicitly ill-formed when called with a typed
 // pointer. The user cannot possibly have a typed pointer to the coroutine.
 // FIXME: This behavior is an extension, and should upstreamed into the TS or
 // the test removed if the TS changes are rejected.
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
-namespace coro = std::experimental;
-
 int main(int, char**)
 {
   {
-    using H = coro::coroutine_handle<>;
-    // expected-error@experimental/coroutine:* 3 {{coroutine_handle<void>::from_address cannot be called with non-void pointers}}
+    using H = std::coroutine_handle<>;
+    // expected-error@coroutine:* 3 {{coroutine_handle<void>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
     H::from_address((const void*)nullptr); // expected-note {{requested here}}
     H::from_address((const char*)nullptr); // expected-note {{requested here}}
   }
   {
-    using H = coro::coroutine_handle<int>;
-    // expected-error@experimental/coroutine:* 1 {{static_assert failed "coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead"}}
+    using H = std::coroutine_handle<int>;
+    // expected-error@coroutine:* 1 {{static_assert failed "coroutine_handle<promise_type>::from_address cannot be used with pointers to the coroutine's promise type; use 'from_promise' instead"}}
     H::from_address((const char*)nullptr); // expected-note {{requested here}}
-    // expected-error@experimental/coroutine:* 1 {{coroutine_handle<promise_type>::from_address cannot be called with non-void pointers}}
+    // expected-error@coroutine:* 1 {{coroutine_handle<promise_type>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
   }
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // static coroutine_handle from_address(void*) noexcept
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class C>
 void do_test() {
   {
     C c = C::from_address(nullptr);
     static_assert(noexcept(C::from_address(nullptr)), "");
     // FIXME: Should the return type not be 'C'?
     static_assert(std::is_same<decltype(C::from_address(nullptr)), C>::value, "");
     assert(c.address() == nullptr);
   }
   {
     char dummy = 42;
     C c = C::from_address((void*)&dummy);
     assert(c.address() == &dummy);
   }
 }
 
 int main(int, char**)
 {
-  do_test<coro::coroutine_handle<>>();
-  do_test<coro::coroutine_handle<int>>();
+  do_test<std::coroutine_handle<> >();
+  do_test<std::coroutine_handle<int> >();
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // UNSUPPORTED: ubsan
 
-// <experimental/coroutine>
+// <coroutine>
 // struct noop_coroutine_promise;
 // using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
 // noop_coroutine_handle noop_coroutine() noexcept;
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 
 #if __has_builtin(__builtin_coro_noop)
 
-namespace coro = std::experimental::coroutines_v1;
-
-
-static_assert(std::is_same<coro::coroutine_handle<coro::noop_coroutine_promise>, coro::noop_coroutine_handle>::value, "");
-static_assert(std::is_same<decltype(coro::noop_coroutine()), coro::noop_coroutine_handle>::value, "");
+static_assert(std::is_same<std::coroutine_handle<std::noop_coroutine_promise>, std::noop_coroutine_handle>::value, "");
+static_assert(std::is_same<decltype(std::noop_coroutine()), std::noop_coroutine_handle>::value, "");
 
 // template <> struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<>
 // {
 // // 18.11.2.7 noop observers
 // constexpr explicit operator bool() const noexcept;
 // constexpr bool done() const noexcept;
 
 // // 18.11.2.8 noop resumption
 // constexpr void operator()() const noexcept;
 // constexpr void resume() const noexcept;
 // constexpr void destroy() const noexcept;
 
 // // 18.11.2.9 noop promise access
 // noop_coroutine_promise& promise() const noexcept;
 
 // // 18.11.2.10 noop address
 // constexpr void* address() const noexcept;
 
 int main(int, char**)
 {
-  auto h = coro::noop_coroutine();
-  coro::coroutine_handle<> base = h;
+  auto h = std::noop_coroutine();
+  std::coroutine_handle<> base = h;
 
   assert(h);
   assert(base);
 
   assert(!h.done());
   assert(!base.done());
 
   h.resume();
   h.destroy();
   h();
   static_assert(h.done() == false, "");
   static_assert(h, "");
 
   h.promise();
   assert(h.address() == base.address());
   assert(h.address() != nullptr);
-  assert(coro::coroutine_handle<>::from_address(h.address()) == base);
+  assert(std::coroutine_handle<>::from_address(h.address()) == base);
 
   return 0;
 }
 
 #else
 
 int main(int, char**) { return 0; }
 
 #endif //  __has_builtin(__builtin_coro_noop)

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise>
 // struct coroutine_handle<Promise>;
 
 // Promise& promise() const
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 struct MyCoro {
   struct promise_type {
     void unhandled_exception() {}
     void return_void() {}
-    coro::suspend_never initial_suspend() { return {}; }
-    coro::suspend_never final_suspend() noexcept { return {}; }
+    std::suspend_never initial_suspend() { return {}; }
+    std::suspend_never final_suspend() noexcept { return {}; }
     MyCoro get_return_object() {
       do_runtime_test();
       return {};
     }
     void do_runtime_test() {
       // Test that a coroutine_handle<const T> can be created from a const
       // promise_type and that it represents the same coroutine as
       // coroutine_handle<T>
-      using CH = coro::coroutine_handle<promise_type>;
-      using CCH = coro::coroutine_handle<const promise_type>;
+      using CH = std::coroutine_handle<promise_type>;
+      using CCH = std::coroutine_handle<const promise_type>;
       const auto &cthis = *this;
       CH h = CH::from_promise(*this);
       CCH h2 = CCH::from_promise(*this);
       CCH h3 = CCH::from_promise(cthis);
       assert(&h.promise() == this);
       assert(&h2.promise() == this);
       assert(&h3.promise() == this);
       assert(h.address() == h2.address());
       assert(h2.address() == h3.address());
     }
   };
 };
 
-MyCoro do_runtime_test() {
-  co_await coro::suspend_never{};
-}
+MyCoro do_runtime_test() { co_await std::suspend_never{}; }
 
 template <class Promise>
-void do_test(coro::coroutine_handle<Promise>&& H) {
+void do_test(std::coroutine_handle<Promise>&& H) {
 
   // FIXME Add a runtime test
   {
     ASSERT_SAME_TYPE(decltype(H.promise()), Promise&);
     LIBCPP_ASSERT_NOT_NOEXCEPT(H.promise());
   }
   {
     auto const& CH = H;
     ASSERT_SAME_TYPE(decltype(CH.promise()), Promise&);
     LIBCPP_ASSERT_NOT_NOEXCEPT(CH.promise());
   }
 }
 
 int main(int, char**)
 {
-  do_test(coro::coroutine_handle<int>{});
-  do_test(coro::coroutine_handle<const int>{});
+  do_test(std::coroutine_handle<int>{});
+  do_test(std::coroutine_handle<const int>{});
   do_runtime_test();
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // void destroy()
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class H>
 auto has_destroy_imp(H&& h, int) -> decltype(h.destroy(), std::true_type{});
 template <class H>
 auto has_destroy_imp(H&&, long) -> std::false_type;
 
 template <class H>
 constexpr bool has_destroy() {
   return decltype(has_destroy_imp(std::declval<H>(), 0))::value;
 }
 
 template <class Promise>
-void do_test(coro::coroutine_handle<Promise>&& H) {
-  using HType = coro::coroutine_handle<Promise>;
+void do_test(std::coroutine_handle<Promise>&& H) {
+  using HType = std::coroutine_handle<Promise>;
   // FIXME Add a runtime test
   {
     ASSERT_SAME_TYPE(decltype(H.destroy()), void);
     LIBCPP_ASSERT_NOT_NOEXCEPT(H.destroy());
     static_assert(has_destroy<HType&>(), "");
     static_assert(has_destroy<HType&&>(), "");
   }
   {
     static_assert(!has_destroy<HType const&>(), "");
     static_assert(!has_destroy<HType const&&>(), "");
   }
 }
 
 int main(int, char**)
 {
-  do_test(coro::coroutine_handle<>{});
-  do_test(coro::coroutine_handle<int>{});
+  do_test(std::coroutine_handle<>{});
+  do_test(std::coroutine_handle<int>{});
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // void operator()()
 // void resume()
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
-
 template <class H>
 auto has_resume_imp(H&& h, int) -> decltype(h.resume(), std::true_type{});
 template <class H>
 auto has_resume_imp(H&&, long) -> std::false_type;
 
 template <class H>
 constexpr bool has_resume() {
   return decltype(has_resume_imp(std::declval<H>(), 0))::value;
 }
 
 
 template <class H>
 auto has_call_operator_imp(H&& h, int) -> decltype(h(), std::true_type{});
 template <class H>
 auto has_call_operator_imp(H&&, long) -> std::false_type;
 
 template <class H>
 constexpr bool has_call_operator() {
   return decltype(has_call_operator_imp(std::declval<H>(), 0))::value;
 }
 
 template <class Promise>
-void do_test(coro::coroutine_handle<Promise>&& H) {
-  using HType = coro::coroutine_handle<Promise>;
+void do_test(std::coroutine_handle<Promise>&& H) {
+  using HType = std::coroutine_handle<Promise>;
   // FIXME Add a runtime test
   {
     ASSERT_SAME_TYPE(decltype(H.resume()), void);
     ASSERT_SAME_TYPE(decltype(H()), void);
     LIBCPP_ASSERT_NOT_NOEXCEPT(H.resume());
     LIBCPP_ASSERT_NOT_NOEXCEPT(H());
     static_assert(has_resume<HType&>(), "");
     static_assert(has_resume<HType&&>(), "");
     static_assert(has_call_operator<HType&>(), "");
     static_assert(has_call_operator<HType&&>(), "");
   }
   {
     static_assert(!has_resume<HType const&>(), "");
     static_assert(!has_resume<HType const&&>(), "");
     static_assert(!has_call_operator<HType const&>(), "");
     static_assert(!has_call_operator<HType const&&>(), "");
   }
 }
 
 int main(int, char**)
 {
-  do_test(coro::coroutine_handle<>{});
-  do_test(coro::coroutine_handle<int>{});
+  do_test(std::coroutine_handle<>{});
+  do_test(std::coroutine_handle<int>{});
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 struct A {
   using promise_type = A*;
 };
 
 struct B {};
 struct C {};
 
-namespace std { namespace experimental {
-  template <>
-  struct coroutine_traits<::A, int> {
-    using promise_type = int*;
+namespace std {
+struct coroutine_traits< ::A, int> {
   };
   template <class ...Args>
   struct coroutine_traits<::B, Args...> {
     using promise_type = B*;
   };
   template <>
   struct coroutine_traits<::C> {
     using promise_type = void;
   };
-}}
+  } // namespace std
 
 template <class Expect, class T, class ...Args>
 void check_type() {
-  using P = typename coro::coroutine_traits<T, Args...>::promise_type ;
+  using P = typename std::coroutine_traits<T, Args...>::promise_type;
   static_assert(std::is_same<P, Expect>::value, "");
 };
 
 int main(int, char**)
 {
   check_type<A*, A>();
   check_type<int*, A, int>();
   check_type<B*, B>();
   check_type<void, C>();
 
   return 0;
 }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 template <class T, class = typename T::promise_type>
 constexpr bool has_promise_type(int) { return true; }
 template <class>
 constexpr bool has_promise_type(long) { return false; }
 template <class T>
 constexpr bool has_promise_type() { return has_promise_type<T>(0); }
 
 struct A {
   using promise_type = A*;
 };
 
 struct B {};
 struct C {};
 struct D {
 private:
   using promise_type = void;
 };
 struct E {};
 
-namespace std { namespace experimental {
-  template <>
-  struct coroutine_traits<::A, int> {
-    using promise_type = int*;
+namespace std {
+struct coroutine_traits< ::A, int> {
   };
   template <class ...Args>
   struct coroutine_traits<::B, Args...> {
     using promise_type = B*;
   };
   template <>
   struct coroutine_traits<::C> {
     using promise_type = void;
   };
-}}
+  } // namespace std
 
 template <class Expect, class T, class ...Args>
 void check_type() {
-  using Traits = coro::coroutine_traits<T, Args...>;
+  using Traits = std::coroutine_traits<T, Args...>;
   static_assert(has_promise_type<Traits>(), "");
   static_assert(std::is_same<typename Traits::promise_type, Expect>::value, "");
 }
 
 template <class T, class ...Args>
 void check_no_type() {
-  using Traits = coro::coroutine_traits<T, Args...>;
+  using Traits = std::coroutine_traits<T, Args...>;
   static_assert(!has_promise_type<Traits>(), "");
 }
 
 int main(int, char**)
 {
   {
     check_type<A*, A>();
     check_type<int*, A, int>();

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
-using SuspendT = std::experimental::coroutines_v1::suspend_always;
+using SuspendT = std::suspend_always;
 
 TEST_SAFE_STATIC SuspendT safe_sa;
 constexpr SuspendT constexpr_sa;
 
 constexpr bool check_suspend_constexpr() {
   SuspendT s{};
   const SuspendT scopy(s); ((void)scopy);
   SuspendT smove(std::move(s)); ((void)smove);
   s = scopy;
   s = std::move(smove);
   return true;
 }
 
 int main(int, char**)
 {
-  using H = coro::coroutine_handle<>;
+  using H = std::coroutine_handle<>;
   using S = SuspendT;
   H h{};
   S s{};
   S const& cs = s;
   {
     LIBCPP_STATIC_ASSERT(noexcept(s.await_ready()), "");
     static_assert(std::is_same<decltype(s.await_ready()), bool>::value, "");
     assert(s.await_ready() == false);

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
-namespace coro = std::experimental;
-
 // Test that the type is in the correct namespace
-using SuspendT = std::experimental::coroutines_v1::suspend_never;
+using SuspendT = std::suspend_never;
 
 TEST_SAFE_STATIC SuspendT safe_sn;
 constexpr SuspendT constexpr_sn;
 
 constexpr bool check_suspend_constexpr() {
   SuspendT s{};
   const SuspendT scopy(s); ((void)scopy);
   SuspendT smove(std::move(s)); ((void)smove);
   s = scopy;
   s = std::move(smove);
   return true;
 }
 
 
 int main(int, char**)
 {
-  using H = coro::coroutine_handle<>;
+  using H = std::coroutine_handle<>;
   using S = SuspendT;
   H h{};
   S s{};
   S const& cs = s;
   {
     LIBCPP_STATIC_ASSERT(noexcept(s.await_ready()), "");
     static_assert(std::is_same<decltype(s.await_ready()), bool>::value, "");
     assert(s.await_ready() == true);

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct coro_t {
   struct promise_type {
     coro_t get_return_object() {
       coroutine_handle<promise_type>{};
       return {};
     }
     suspend_never initial_suspend() { return {}; }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
 // See https://llvm.org/PR33271
 // UNSUPPORTED: ubsan
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct coro_t {
   struct promise_type {
     coro_t get_return_object() {
       return coroutine_handle<promise_type>::from_promise(*this);
     }
     suspend_never initial_suspend() { return {}; }
     suspend_never final_suspend() noexcept { return {}; }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 #include <memory>
 
 #include "test_macros.h"
-using namespace std::experimental;
+using namespace std;
 
 struct error_tag { };
 
 template <typename T, typename Error = int>
 struct expected {
 
   struct Data {
     Data() : val(), error() { }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 int alive = 0;
 int ctor_called = 0;
 int dtor_called = 0;
 void reset() {
   assert(alive == 0);
   alive = 0;
   ctor_called = 0;
   dtor_called = 0;
 }
 struct Noisy {
   Noisy() { ++alive; ++ctor_called; }
   ~Noisy() { --alive; ++dtor_called; }
 #if TEST_STD_VER > 14
   Noisy(Noisy const&) = delete;
 #else
   // FIXME: This test depends on copy elision taking place in C++14
   // (pre-C++17 guaranteed copy elision)
   Noisy(Noisy const&);
 #endif
 };
 
 struct Bug {
   bool await_ready() { return true; }
-  void await_suspend(std::experimental::coroutine_handle<>) {}
+  void await_suspend(std::coroutine_handle<>) {}
   Noisy await_resume() { return {}; }
 };
 struct coro2 {
   struct promise_type {
     suspend_never initial_suspend() { return{}; }
     suspend_never final_suspend() noexcept { return {}; }
     coro2 get_return_object() { return{}; }
     void return_void() {}

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
 // See https://llvm.org/PR33271
 // UNSUPPORTED: ubsan
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "coroutine_types.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct minig {
   struct promise_type {
     int current_value;
     suspend_always yield_value(int value) {
       this->current_value = value;
       return {};
     }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 bool cancel = false;
 
 struct goroutine
 {
   static int const N = 10;
   static int count;
   static coroutine_handle<> stack[N];

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 // This file tests, multishot, movable std::function like thing using coroutine
 // for compile-time type erasure and unerasure.
 template <typename R> struct func {
   struct Input {R a, b;};
 
   struct promise_type {
     Input* I;

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-#include <experimental/coroutine>
+#include <coroutine>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
-using namespace std::experimental;
+using namespace std;
 
 // This file tests, one shot, movable std::function like thing using coroutine
 // for compile-time type erasure and unerasure.
 
 template <typename R> struct func {
   struct promise_type {
     R result;
     func get_return_object() { return {this}; }

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
-// <experimental/coroutine>
+// <coroutine>
 
-// Test that <experimental/coroutine> includes <new>
+// Test that <coroutine> includes <new>
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 int main(int, char**) {
   // std::nothrow is not implicitly defined by the compiler when the include is
   // missing, unlike other parts of <new>. Therefore we use std::nothrow to
   // test for #include <new>
 
   (void)std::nothrow;
 
   return 0;
 }

libcxx/test/support/coroutine_types.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUPPORT_COROUTINE_TYPES_H
 #define SUPPORT_COROUTINE_TYPES_H
 
-#include <experimental/coroutine>
+#include <coroutine>
 
 template <typename Ty> struct generator {
   struct promise_type {
     Ty current_value;
-    std::experimental::suspend_always yield_value(Ty value) {
+    std::suspend_always yield_value(Ty value) {
       this->current_value = value;
       return {};
     }
-    std::experimental::suspend_always initial_suspend() { return {}; }
-    std::experimental::suspend_always final_suspend() noexcept { return {}; }
+    std::suspend_always initial_suspend() { return {}; }
+    std::suspend_always final_suspend() noexcept { return {}; }
     generator get_return_object() { return generator{this}; };
     void return_void() {}
     void unhandled_exception() {}
   };
 
   struct iterator {
-    std::experimental::coroutine_handle<promise_type> _Coro;
+    std::coroutine_handle<promise_type> _Coro;
     bool _Done;
 
-    iterator(std::experimental::coroutine_handle<promise_type> Coro, bool Done)
-        : _Coro(Coro), _Done(Done) {}
+    iterator(std::coroutine_handle<promise_type> Coro, bool Done) : _Coro(Coro), _Done(Done) {}
 
     iterator &operator++() {
       _Coro.resume();
       _Done = _Coro.done();
       return *this;
     }
 
     bool operator==(iterator const &_Right) const {
template <typename Ty> struct generator {
   generator(generator &&rhs) : p(rhs.p) { rhs.p = nullptr; }
 
   ~generator() {
     if (p)
       p.destroy();
   }
 
 private:
-  explicit generator(promise_type *p)
-      : p(std::experimental::coroutine_handle<promise_type>::from_promise(*p)) {}
+  explicit generator(promise_type* p) : p(std::coroutine_handle<promise_type>::from_promise(*p)) {}
 
-  std::experimental::coroutine_handle<promise_type> p;
+  std::coroutine_handle<promise_type> p;
 };
 
 #endif // SUPPORT_COROUTINE_TYPES_H

libcxx/utils/generate_header_tests.py

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