diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/readability-identifier-naming/system/coroutines.h b/clang-tools-extra/test/clang-tidy/checkers/Inputs/readability-identifier-naming/system/coroutines.h
--- a/clang-tools-extra/test/clang-tidy/checkers/Inputs/readability-identifier-naming/system/coroutines.h
+++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/readability-identifier-naming/system/coroutines.h
@@ -1,7 +1,6 @@
 #pragma once
 
 namespace std {
-namespace experimental {
 
 template <typename ret_t, typename... args_t>
 struct coroutine_traits {
@@ -13,7 +12,6 @@
   static constexpr coroutine_handle from_address(void *addr) noexcept { return {}; };
 };
 
-} // namespace experimental
 } // namespace std
 
 struct never_suspend {
diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst
--- a/clang/docs/LanguageExtensions.rst
+++ b/clang/docs/LanguageExtensions.rst
@@ -2947,7 +2947,7 @@
 
 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 the ``std::coroutine_handle`` type.
 
 **Syntax**:
 
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -11003,19 +11003,25 @@
   "|a function with a deduced return type|a varargs function"
   "|a consteval function}0">;
 def err_implied_coroutine_type_not_found : Error<
-  "%0 type was not found; include <experimental/coroutine> before defining "
-  "a coroutine">;
+  "%0 type was not found; include <coroutine> before defining "
+  "a coroutine; include <experimental/coroutine> if your version "
+  "of libcxx is less than 14.0">;
+def err_mixed_use_std_and_experimental_namespace_for_coroutine : Error <
+  "Found mixed use of std namespace and std::experimental namespace for "
+  "coroutine, which is disallowed. The coroutine components in "
+  "std::experimental namespace is deprecated. Please use coroutine components "
+  "under std namespace.">;
 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 isn't a class template">;
 def err_coroutine_handle_missing_member : Error<
-  "std::experimental::coroutine_handle missing a member named '%0'">;
+  "std::coroutine_handle must have a member named '%0'">;
 def err_malformed_std_coroutine_traits : Error<
-  "'std::experimental::coroutine_traits' must be a class template">;
+  "std::coroutine_traits isn't 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<
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -1124,6 +1124,10 @@
   /// The C++ "std::coroutine_traits" template, which is defined in
   /// \<coroutine_traits>
   ClassTemplateDecl *StdCoroutineTraitsCache;
+  /// The namespace where coroutine components are defined. In standard,
+  /// they are defined in std namespace. And in the previous implementation,
+  /// they are defined in std::experimental namespace.
+  NamespaceDecl *CoroTraitsNamespaceCache;
 
   /// The C++ "type_info" declaration, which is defined in \<typeinfo>.
   RecordDecl *CXXTypeInfoDecl;
@@ -5696,6 +5700,7 @@
   NamespaceDecl *getOrCreateStdNamespace();
 
   NamespaceDecl *lookupStdExperimentalNamespace();
+  NamespaceDecl *getCachedCoroNamespace() { return CoroTraitsNamespaceCache; }
 
   CXXRecordDecl *getStdBadAlloc() const;
   EnumDecl *getStdAlignValT() const;
@@ -10265,8 +10270,11 @@
   bool buildCoroutineParameterMoves(SourceLocation Loc);
   VarDecl *buildCoroutinePromise(SourceLocation Loc);
   void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);
+  /// Lookup 'coroutine_traits' in std namespace and std::experimental
+  /// namespace. The namespace found is recorded in Namespace.
   ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc,
-                                           SourceLocation FuncLoc);
+                                           SourceLocation FuncLoc,
+                                           NamespaceDecl *&Namespace);
   /// Check that the expression co_await promise.final_suspend() shall not be
   /// potentially-throwing.
   bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend);
diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
--- a/clang/lib/Frontend/InitPreprocessor.cpp
+++ b/clang/lib/Frontend/InitPreprocessor.cpp
@@ -600,7 +600,7 @@
     //Builder.defineMacro("__cpp_consteval", "201811L");
     Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");
     Builder.defineMacro("__cpp_constinit", "201907L");
-    //Builder.defineMacro("__cpp_coroutines", "201902L");
+    Builder.defineMacro("__cpp_impl_coroutine", "201902L");
     Builder.defineMacro("__cpp_designated_initializers", "201707L");
     Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");
     //Builder.defineMacro("__cpp_modules", "201907L");
diff --git a/clang/lib/Sema/SemaCoroutine.cpp b/clang/lib/Sema/SemaCoroutine.cpp
--- a/clang/lib/Sema/SemaCoroutine.cpp
+++ b/clang/lib/Sema/SemaCoroutine.cpp
@@ -53,15 +53,10 @@
                                   SourceLocation KwLoc) {
   const FunctionProtoType *FnType = FD->getType()->castAs<FunctionProtoType>();
   const SourceLocation FuncLoc = FD->getLocation();
-  // FIXME: Cache std::coroutine_traits once we've found it.
-  NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
-  if (!StdExp) {
-    S.Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
-        << "std::experimental::coroutine_traits";
-    return QualType();
-  }
 
-  ClassTemplateDecl *CoroTraits = S.lookupCoroutineTraits(KwLoc, FuncLoc);
+  NamespaceDecl *CoroNamespace = nullptr;
+  ClassTemplateDecl *CoroTraits =
+      S.lookupCoroutineTraits(KwLoc, FuncLoc, CoroNamespace);
   if (!CoroTraits) {
     return QualType();
   }
@@ -122,7 +117,7 @@
   QualType PromiseType = S.Context.getTypeDeclType(Promise);
 
   auto buildElaboratedType = [&]() {
-    auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, StdExp);
+    auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, CoroNamespace);
     NNS = NestedNameSpecifier::Create(S.Context, NNS, false,
                                       CoroTrait.getTypePtr());
     return S.Context.getElaboratedType(ETK_None, NNS, PromiseType);
@@ -141,20 +136,20 @@
   return PromiseType;
 }
 
-/// Look up the std::experimental::coroutine_handle<PromiseType>.
+/// Look up the std::coroutine_handle<PromiseType>.
 static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType,
                                           SourceLocation Loc) {
   if (PromiseType.isNull())
     return QualType();
 
-  NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
-  assert(StdExp && "Should already be diagnosed");
+  NamespaceDecl *CoroNamespace = S.getCachedCoroNamespace();
+  assert(CoroNamespace && "Should already be diagnosed");
 
   LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_handle"),
                       Loc, Sema::LookupOrdinaryName);
-  if (!S.LookupQualifiedName(Result, StdExp)) {
+  if (!S.LookupQualifiedName(Result, CoroNamespace)) {
     S.Diag(Loc, diag::err_implied_coroutine_type_not_found)
-        << "std::experimental::coroutine_handle";
+        << "std::coroutine_handle";
     return QualType();
   }
 
@@ -1000,7 +995,7 @@
   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);
@@ -1663,25 +1658,47 @@
 }
 
 ClassTemplateDecl *Sema::lookupCoroutineTraits(SourceLocation KwLoc,
-                                               SourceLocation FuncLoc) {
+                                               SourceLocation FuncLoc,
+                                               NamespaceDecl *&Namespace) {
   if (!StdCoroutineTraitsCache) {
-    if (auto StdExp = lookupStdExperimentalNamespace()) {
-      LookupResult Result(*this,
-                          &PP.getIdentifierTable().get("coroutine_traits"),
-                          FuncLoc, LookupOrdinaryName);
-      if (!LookupQualifiedName(Result, StdExp)) {
+    NamespaceDecl *CoroNamespace = getStdNamespace();
+    LookupResult Result(*this, &PP.getIdentifierTable().get("coroutine_traits"),
+                        FuncLoc, LookupOrdinaryName);
+
+    if (!CoroNamespace || !LookupQualifiedName(Result, CoroNamespace)) {
+      /// Look up in namespace std::experimental, for compatibility.
+      /// TODO: Remove this extra lookup when <experimental/coroutine> is
+      /// removed.
+      CoroNamespace = lookupStdExperimentalNamespace();
+      if (!CoroNamespace || !LookupQualifiedName(Result, CoroNamespace)) {
         Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
-            << "std::experimental::coroutine_traits";
+            << "std::coroutine_traits";
         return nullptr;
       }
-      if (!(StdCoroutineTraitsCache =
-                Result.getAsSingle<ClassTemplateDecl>())) {
-        Result.suppressDiagnostics();
-        NamedDecl *Found = *Result.begin();
-        Diag(Found->getLocation(), diag::err_malformed_std_coroutine_traits);
+      /// TODO: Add a warning about not including <experimental/coroutine>
+      /// once we update libcxx.
+    } else {
+      /// When we found coroutine_traits in std namespace. Make sure there is no
+      /// misleading definition in std::experimental namespace.
+      NamespaceDecl *ExpNamespace = lookupStdExperimentalNamespace();
+      LookupResult ExpResult(*this,
+                             &PP.getIdentifierTable().get("coroutine_traits"),
+                             FuncLoc, LookupOrdinaryName);
+      if (ExpNamespace && LookupQualifiedName(ExpResult, ExpNamespace)) {
+        Diag(KwLoc,
+             diag::err_mixed_use_std_and_experimental_namespace_for_coroutine);
         return nullptr;
       }
     }
+
+    if (!(StdCoroutineTraitsCache = Result.getAsSingle<ClassTemplateDecl>())) {
+      Result.suppressDiagnostics();
+      NamedDecl *Found = *Result.begin();
+      Diag(Found->getLocation(), diag::err_malformed_std_coroutine_traits);
+      return nullptr;
+    }
+    CoroTraitsNamespaceCache = CoroNamespace;
   }
+  Namespace = CoroTraitsNamespaceCache;
   return StdCoroutineTraitsCache;
 }
diff --git a/clang/test/AST/Inputs/std-coroutine.h b/clang/test/AST/Inputs/std-coroutine-exp-namespace.h
copy from clang/test/AST/Inputs/std-coroutine.h
copy to clang/test/AST/Inputs/std-coroutine-exp-namespace.h
--- a/clang/test/AST/Inputs/std-coroutine.h
+++ b/clang/test/AST/Inputs/std-coroutine-exp-namespace.h
@@ -4,7 +4,6 @@
 
 namespace std {
 namespace experimental {
-
 template <typename R, typename...> struct coroutine_traits {
   using promise_type = typename R::promise_type;
 };
@@ -66,7 +65,6 @@
   void await_suspend(coroutine_handle<>) noexcept {}
   void await_resume() noexcept {}
 };
-
 } // namespace experimental
 } // namespace std
 
diff --git a/clang/test/AST/Inputs/std-coroutine.h b/clang/test/AST/Inputs/std-coroutine.h
--- a/clang/test/AST/Inputs/std-coroutine.h
+++ b/clang/test/AST/Inputs/std-coroutine.h
@@ -1,9 +1,8 @@
-// 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
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 -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;
@@ -67,7 +66,6 @@
   void await_resume() noexcept {}
 };
 
-} // namespace experimental
 } // namespace std
 
 #endif // STD_COROUTINE_H
diff --git a/clang/test/AST/coroutine-locals-cleanup.cpp b/clang/test/AST/coroutine-locals-cleanup-exp-namespace.cpp
copy from clang/test/AST/coroutine-locals-cleanup.cpp
copy to clang/test/AST/coroutine-locals-cleanup-exp-namespace.cpp
--- a/clang/test/AST/coroutine-locals-cleanup.cpp
+++ b/clang/test/AST/coroutine-locals-cleanup-exp-namespace.cpp
@@ -1,6 +1,6 @@
 // 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"
+#include "Inputs/std-coroutine-exp-namespace.h"
 
 using namespace std::experimental;
 
diff --git a/clang/test/AST/coroutine-locals-cleanup.cpp b/clang/test/AST/coroutine-locals-cleanup.cpp
--- a/clang/test/AST/coroutine-locals-cleanup.cpp
+++ b/clang/test/AST/coroutine-locals-cleanup.cpp
@@ -1,8 +1,8 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -fsyntax-only -ast-dump %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -fsyntax-only -ast-dump %s | FileCheck %s
 
 #include "Inputs/std-coroutine.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct Task {
   struct promise_type {
diff --git a/clang/test/AST/coroutine-source-location-crash.cpp b/clang/test/AST/coroutine-source-location-crash-exp-namespace.cpp
copy from clang/test/AST/coroutine-source-location-crash.cpp
copy to clang/test/AST/coroutine-source-location-crash-exp-namespace.cpp
--- a/clang/test/AST/coroutine-source-location-crash.cpp
+++ b/clang/test/AST/coroutine-source-location-crash-exp-namespace.cpp
@@ -9,7 +9,7 @@
 // RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
 // RUN: | FileCheck %s
 
-#include "Inputs/std-coroutine.h"
+#include "Inputs/std-coroutine-exp-namespace.h"
 
 using namespace std::experimental;
 
diff --git a/clang/test/AST/coroutine-source-location-crash.cpp b/clang/test/AST/coroutine-source-location-crash.cpp
--- a/clang/test/AST/coroutine-source-location-crash.cpp
+++ b/clang/test/AST/coroutine-source-location-crash.cpp
@@ -1,17 +1,17 @@
 // Test without serialization:
-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 \
 // 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: %clang_cc1 -triple x86_64-apple-darwin9 -std=c++20 -emit-pch -o %t %s
+// RUN: %clang_cc1 -x c++ -triple x86_64-apple-darwin9 -std=c++20 -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();
diff --git a/clang/test/Analysis/more-dtors-cfg-output.cpp b/clang/test/Analysis/more-dtors-cfg-output.cpp
--- a/clang/test/Analysis/more-dtors-cfg-output.cpp
+++ b/clang/test/Analysis/more-dtors-cfg-output.cpp
@@ -275,32 +275,32 @@
 #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 {
+template <typename Promise>
+struct coroutine_handle {
+  static coroutine_handle from_address(void *) noexcept;
+};
+} // 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 {
+template <typename Ret, typename... Args>
+struct coroutine_traits;
+template <>
+struct coroutine_traits<Bar> {
+  using promise_type = TestPromise;
+};
+} // namespace std
 
 Bar coreturn() {
   co_return get_bar();
diff --git a/clang/test/CodeGenCXX/ubsan-coroutines.cpp b/clang/test/CodeGenCXX/ubsan-coroutines.cpp
--- a/clang/test/CodeGenCXX/ubsan-coroutines.cpp
+++ b/clang/test/CodeGenCXX/ubsan-coroutines.cpp
@@ -2,7 +2,7 @@
 // crash when the LLVM coroutines passes are run.
 // RUN: %clang_cc1 -emit-obj -std=c++2a -fsanitize=null %s -o %t.o
 
-namespace std::experimental {
+namespace std {
 template <typename R, typename... T> struct coroutine_traits {
   using promise_type = typename R::promise_type;
 };
@@ -18,11 +18,11 @@
   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;
 };
 
@@ -39,7 +39,7 @@
 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; }
 };
 
diff --git a/clang/test/AST/Inputs/std-coroutine.h b/clang/test/CodeGenCoroutines/Inputs/coroutine-exp-namespace.h
copy from clang/test/AST/Inputs/std-coroutine.h
copy to clang/test/CodeGenCoroutines/Inputs/coroutine-exp-namespace.h
--- a/clang/test/AST/Inputs/std-coroutine.h
+++ b/clang/test/CodeGenCoroutines/Inputs/coroutine-exp-namespace.h
@@ -1,9 +1,8 @@
-// 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
+#pragma once
 
 namespace std {
 namespace experimental {
+inline namespace coroutines_v1 {
 
 template <typename R, typename...> struct coroutine_traits {
   using promise_type = typename R::promise_type;
@@ -55,19 +54,29 @@
   }
 };
 
+template <typename _PromiseT>
+bool operator==(coroutine_handle<_PromiseT> const &_Left,
+                coroutine_handle<_PromiseT> const &_Right) noexcept {
+  return _Left.address() == _Right.address();
+}
+
+template <typename _PromiseT>
+bool operator!=(coroutine_handle<_PromiseT> const &_Left,
+                coroutine_handle<_PromiseT> const &_Right) noexcept {
+  return !(_Left == _Right);
+}
+
 struct suspend_always {
   bool await_ready() { return false; }
   void await_suspend(coroutine_handle<>) {}
   void await_resume() {}
 };
-
 struct suspend_never {
   bool await_ready() noexcept { return true; }
   void await_suspend(coroutine_handle<>) noexcept {}
   void await_resume() noexcept {}
 };
 
+} // namespace coroutines_v1
 } // namespace experimental
 } // namespace std
-
-#endif // STD_COROUTINE_H
diff --git a/clang/test/CodeGenCoroutines/Inputs/coroutine.h b/clang/test/CodeGenCoroutines/Inputs/coroutine.h
--- a/clang/test/CodeGenCoroutines/Inputs/coroutine.h
+++ b/clang/test/CodeGenCoroutines/Inputs/coroutine.h
@@ -1,6 +1,6 @@
 #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;
@@ -77,4 +77,4 @@
   void await_resume() noexcept {}
 };
 
-}}}
+} // namespace std
diff --git a/clang/test/CodeGenCoroutines/coro-alloc.cpp b/clang/test/CodeGenCoroutines/coro-alloc-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-alloc.cpp
copy to clang/test/CodeGenCoroutines/coro-alloc-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-alloc.cpp
+++ b/clang/test/CodeGenCoroutines/coro-alloc-exp-namespace.cpp
@@ -31,9 +31,8 @@
 // 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;
-
+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; }
@@ -43,7 +42,7 @@
 
 struct global_new_delete_tag {};
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<void, global_new_delete_tag> {
   struct promise_type {
     void get_return_object() {}
@@ -83,7 +82,7 @@
 
 struct promise_new_tag {};
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<void, promise_new_tag> {
   struct promise_type {
     void *operator new(unsigned long);
@@ -95,7 +94,7 @@
 };
 
 // CHECK-LABEL: f1(
-extern "C" void f1(promise_new_tag ) {
+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]])
@@ -108,7 +107,7 @@
 
 struct promise_matching_placement_new_tag {};
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<void, promise_matching_placement_new_tag, int, float, double> {
   struct promise_type {
     void *operator new(unsigned long, promise_matching_placement_new_tag,
@@ -121,7 +120,7 @@
 };
 
 // CHECK-LABEL: f1a(
-extern "C" void f1a(promise_matching_placement_new_tag, int x, float y , double z) {
+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
@@ -136,12 +135,12 @@
 
 // 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;
+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::experimental::coroutine_traits<void, promise_matching_global_placement_new_tag, dummy *> {
   struct promise_type {
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
@@ -162,10 +161,10 @@
 
 struct promise_delete_tag {};
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<void, promise_delete_tag> {
   struct promise_type {
-    void operator delete(void*);
+    void operator delete(void *);
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
@@ -187,10 +186,10 @@
 
 struct promise_sized_delete_tag {};
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<void, promise_sized_delete_tag> {
   struct promise_type {
-    void operator delete(void*, unsigned long);
+    void operator delete(void *, unsigned long);
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
@@ -213,7 +212,7 @@
 
 struct promise_on_alloc_failure_tag {};
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<int, promise_on_alloc_failure_tag> {
   struct promise_type {
     int get_return_object() { return 0; }
diff --git a/clang/test/CodeGenCoroutines/coro-alloc.cpp b/clang/test/CodeGenCoroutines/coro-alloc.cpp
--- a/clang/test/CodeGenCoroutines/coro-alloc.cpp
+++ b/clang/test/CodeGenCoroutines/coro-alloc.cpp
@@ -1,9 +1,8 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 \
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 \
 // 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}}
 
@@ -21,8 +20,6 @@
   coroutine_handle(coroutine_handle<PromiseType>) noexcept {}
 };
 
-} // end namespace experimental
-
 struct nothrow_t {};
 constexpr nothrow_t nothrow = {};
 
@@ -37,14 +34,14 @@
 
 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 {}; }
@@ -83,8 +80,8 @@
 
 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() {}
@@ -98,7 +95,7 @@
 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]])
@@ -108,8 +105,8 @@
 
 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);
@@ -130,7 +127,7 @@
   // 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;
 }
 
@@ -140,8 +137,8 @@
 
 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 {}; }
@@ -162,8 +159,8 @@
 
 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() {}
@@ -181,14 +178,14 @@
 
   // 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() {}
@@ -207,14 +204,14 @@
   // 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 {}; }
@@ -235,12 +232,12 @@
   // 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]]
diff --git a/clang/test/CodeGenCoroutines/coro-always-inline.cpp b/clang/test/CodeGenCoroutines/coro-always-inline-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-always-inline.cpp
copy to clang/test/CodeGenCoroutines/coro-always-inline-exp-namespace.cpp
diff --git a/clang/test/CodeGenCoroutines/coro-always-inline.cpp b/clang/test/CodeGenCoroutines/coro-always-inline.cpp
--- a/clang/test/CodeGenCoroutines/coro-always-inline.cpp
+++ b/clang/test/CodeGenCoroutines/coro-always-inline.cpp
@@ -1,15 +1,14 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fcoroutines-ts \
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -std=c++20 \
 // RUN:   -fexperimental-new-pass-manager -O0 %s -o - | FileCheck %s
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fcoroutines-ts \
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -std=c++20 \
 // 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: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -std=c++20 \
 // RUN:   -O0 %s -o - | FileCheck %s
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fcoroutines-ts \
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -std=c++20 \
 // RUN:   -fno-inline -O0 %s -o - | FileCheck %s
 
 namespace std {
-namespace experimental {
 
 struct handle {};
 
@@ -35,18 +34,17 @@
     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; }
diff --git a/clang/test/CodeGenCoroutines/coro-await-domination.cpp b/clang/test/CodeGenCoroutines/coro-await-domination-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-await-domination.cpp
copy to clang/test/CodeGenCoroutines/coro-await-domination-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-await-domination.cpp
+++ b/clang/test/CodeGenCoroutines/coro-await-domination-exp-namespace.cpp
@@ -1,5 +1,5 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm %s -o - | FileCheck %s
-#include "Inputs/coroutine.h"
+#include "Inputs/coroutine-exp-namespace.h"
 
 using namespace std::experimental;
 
@@ -28,7 +28,6 @@
 //  %tmp.exprcleanup = alloca i32*, align 8
 //  store i32* %x, i32** %tmp.exprcleanup, align 8
 
-
 // CHECK-LABEL: f(
 extern "C" coro f(int) {
   int x = 42;
diff --git a/clang/test/CodeGenCoroutines/coro-await-domination.cpp b/clang/test/CodeGenCoroutines/coro-await-domination.cpp
--- a/clang/test/CodeGenCoroutines/coro-await-domination.cpp
+++ b/clang/test/CodeGenCoroutines/coro-await-domination.cpp
@@ -1,7 +1,7 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -emit-llvm %s -o - | FileCheck %s
 #include "Inputs/coroutine.h"
 
-using namespace std::experimental;
+using namespace std;
 
 struct coro {
   struct promise_type {
diff --git a/clang/test/CodeGenCoroutines/coro-await.cpp b/clang/test/CodeGenCoroutines/coro-await-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-await.cpp
copy to clang/test/CodeGenCoroutines/coro-await-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-await.cpp
+++ b/clang/test/CodeGenCoroutines/coro-await-exp-namespace.cpp
@@ -20,8 +20,8 @@
   static coroutine_handle from_address(void *) noexcept;
 };
 
-}
-}
+} // namespace experimental
+} // namespace std
 
 struct init_susp {
   bool await_ready();
@@ -41,7 +41,7 @@
   void await_resume();
 };
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<void> {
   struct promise_type {
     void get_return_object();
@@ -113,9 +113,8 @@
   void await_resume();
 };
 
-
-template<>
-struct std::experimental::coroutine_traits<void,int> {
+template <>
+struct std::experimental::coroutine_traits<void, int> {
   struct promise_type {
     void get_return_object();
     init_susp initial_suspend();
@@ -180,7 +179,10 @@
   // CHECK: call <2 x float> @_ZN14ComplexAwaiter12await_resumeEv(%struct.ComplexAwaiter*
 }
 
-struct Aggr { int X, Y, Z; ~Aggr(); };
+struct Aggr {
+  int X, Y, Z;
+  ~Aggr();
+};
 struct AggrAwaiter {
   template <typename F> void await_suspend(F);
   bool await_ready();
@@ -188,7 +190,7 @@
 };
 
 extern "C" void Whatever();
-extern "C" void UseAggr(Aggr&&);
+extern "C" void UseAggr(Aggr &&);
 
 // FIXME: Once the cleanup code is in, add testing that destructors for Aggr
 // are invoked properly on the cleanup branches.
@@ -240,7 +242,7 @@
 }
 
 // Test operator co_await codegen.
-enum class MyInt: int {};
+enum class MyInt : int {};
 ScalarAwaiter operator co_await(MyInt);
 
 struct MyAgg {
@@ -283,17 +285,16 @@
   co_await lval;
 }
 
-struct RefTag { };
+struct RefTag {};
 
 struct AwaitResumeReturnsLValue {
   bool await_ready();
   void await_suspend(std::experimental::coroutine_handle<>);
-  RefTag& await_resume();
+  RefTag &await_resume();
 };
 
-
-template<>
-struct std::experimental::coroutine_traits<void,double> {
+template <>
+struct std::experimental::coroutine_traits<void, double> {
   struct promise_type {
     void get_return_object();
     init_susp initial_suspend();
@@ -321,19 +322,19 @@
 
   // CHECK: %[[RES1:.+]] = call nonnull align 1 dereferenceable({{.*}}) %struct.RefTag* @_ZN24AwaitResumeReturnsLValue12await_resumeEv(%struct.AwaitResumeReturnsLValue* {{[^,]*}} %[[AVAR]])
   // CHECK-NEXT: store %struct.RefTag* %[[RES1]], %struct.RefTag** %[[XVAR]],
-  RefTag& x = co_await a;
+  RefTag &x = co_await a;
 
   // CHECK: %[[RES2:.+]] = call nonnull align 1 dereferenceable({{.*}}) %struct.RefTag* @_ZN24AwaitResumeReturnsLValue12await_resumeEv(%struct.AwaitResumeReturnsLValue* {{[^,]*}} %[[TMP1]])
   // CHECK-NEXT: store %struct.RefTag* %[[RES2]], %struct.RefTag** %[[TMP_EXPRCLEANUP1]],
   // CHECK: %[[LOAD_TMP1:.+]] = load %struct.RefTag*, %struct.RefTag** %[[TMP_EXPRCLEANUP1]],
   // CHECK: store %struct.RefTag* %[[LOAD_TMP1]], %struct.RefTag** %[[YVAR]],
 
-  RefTag& y = co_await AwaitResumeReturnsLValue{};
+  RefTag &y = co_await AwaitResumeReturnsLValue{};
   // CHECK: %[[RES3:.+]] = call nonnull align 1 dereferenceable({{.*}}) %struct.RefTag* @_ZN24AwaitResumeReturnsLValue12await_resumeEv(%struct.AwaitResumeReturnsLValue* {{[^,]*}} %[[TMP2]])
   // 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;
+  RefTag &z = co_yield 42;
 }
 
 struct TailCallAwait {
diff --git a/clang/test/CodeGenCoroutines/coro-await-resume-eh.cpp b/clang/test/CodeGenCoroutines/coro-await-resume-eh-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-await-resume-eh.cpp
copy to clang/test/CodeGenCoroutines/coro-await-resume-eh-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-await-resume-eh.cpp
+++ b/clang/test/CodeGenCoroutines/coro-await-resume-eh-exp-namespace.cpp
@@ -8,7 +8,7 @@
 // RUN:   -fexceptions -fcxx-exceptions -disable-llvm-passes \
 // RUN:   | FileCheck %s
 
-#include "Inputs/coroutine.h"
+#include "Inputs/coroutine-exp-namespace.h"
 
 namespace coro = std::experimental::coroutines_v1;
 
diff --git a/clang/test/CodeGenCoroutines/coro-await-resume-eh.cpp b/clang/test/CodeGenCoroutines/coro-await-resume-eh.cpp
--- a/clang/test/CodeGenCoroutines/coro-await-resume-eh.cpp
+++ b/clang/test/CodeGenCoroutines/coro-await-resume-eh.cpp
@@ -3,18 +3,16 @@
 // executing the handler specified by the promise type's 'unhandled_exception'
 // member function.
 //
-// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts \
+// RUN: %clang_cc1 -std=c++20 \
 // 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; }
 };
 
@@ -22,7 +20,7 @@
   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() {}
   };
@@ -88,7 +86,7 @@
 
 struct noexcept_awaitable {
   bool await_ready() { return true; }
-  void await_suspend(coro::coroutine_handle<>) {}
+  void await_suspend(std::coroutine_handle<>) {}
   void await_resume() noexcept {}
 };
 
@@ -96,7 +94,7 @@
   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() {}
   };
diff --git a/clang/test/CodeGenCoroutines/coro-await.cpp b/clang/test/CodeGenCoroutines/coro-await.cpp
--- a/clang/test/CodeGenCoroutines/coro-await.cpp
+++ b/clang/test/CodeGenCoroutines/coro-await.cpp
@@ -1,8 +1,7 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 \
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 \
 // RUN:   -emit-llvm %s -o - -disable-llvm-passes -Wno-coroutine -Wno-unused | FileCheck %s
 
 namespace std {
-namespace experimental {
 template <typename... T>
 struct coroutine_traits;
 
@@ -20,29 +19,28 @@
   static coroutine_handle from_address(void *) noexcept;
 };
 
-}
-}
+} // namespace std
 
 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();
@@ -57,7 +55,7 @@
 
   // 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)
@@ -75,10 +73,10 @@
   // ---------------------------
   // 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:
   // -------------------------
@@ -99,7 +97,7 @@
 
   // 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)
@@ -109,13 +107,12 @@
   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();
@@ -127,10 +124,10 @@
 
 // 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:
   // --------------------------
@@ -144,10 +141,10 @@
   // ---------------------------
   // 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
   // -------------------------------------------
@@ -264,7 +261,7 @@
 
   // 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 (;;)
@@ -272,7 +269,7 @@
 
   // 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*
 }
 
@@ -287,13 +284,12 @@
 
 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();
@@ -338,7 +334,7 @@
 
 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();
 };
 
@@ -346,9 +342,9 @@
 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]])
 }
diff --git a/clang/test/CodeGenCoroutines/coro-cleanup.cpp b/clang/test/CodeGenCoroutines/coro-cleanup-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-cleanup.cpp
copy to clang/test/CodeGenCoroutines/coro-cleanup-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-cleanup.cpp
+++ b/clang/test/CodeGenCoroutines/coro-cleanup-exp-namespace.cpp
@@ -14,7 +14,7 @@
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std::experimental
 
 struct suspend_always {
   bool await_ready() noexcept;
@@ -34,7 +34,9 @@
   };
 };
 
-struct Cleanup { ~Cleanup(); };
+struct Cleanup {
+  ~Cleanup();
+};
 void may_throw();
 
 // CHECK-LABEL: define{{.*}} void @_Z1fv(
diff --git a/clang/test/CodeGenCoroutines/coro-cleanup.cpp b/clang/test/CodeGenCoroutines/coro-cleanup.cpp
--- a/clang/test/CodeGenCoroutines/coro-cleanup.cpp
+++ b/clang/test/CodeGenCoroutines/coro-cleanup.cpp
@@ -1,7 +1,7 @@
 // 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
+// RUN: %clang_cc1 -std=c++20 -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 {
@@ -14,15 +14,15 @@
   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;
@@ -43,7 +43,7 @@
 
   // 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]]:
@@ -67,7 +67,7 @@
 
   // 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
 
@@ -77,7 +77,7 @@
   // 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]]
 
@@ -93,5 +93,5 @@
   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
 }
diff --git a/clang/test/CodeGenCoroutines/coro-dest-slot.cpp b/clang/test/CodeGenCoroutines/coro-dest-slot-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-dest-slot.cpp
copy to clang/test/CodeGenCoroutines/coro-dest-slot-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-dest-slot.cpp
+++ b/clang/test/CodeGenCoroutines/coro-dest-slot-exp-namespace.cpp
@@ -1,6 +1,6 @@
 // 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"
+#include "Inputs/coroutine-exp-namespace.h"
 
 using namespace std::experimental;
 
diff --git a/clang/test/CodeGenCoroutines/coro-dest-slot.cpp b/clang/test/CodeGenCoroutines/coro-dest-slot.cpp
--- a/clang/test/CodeGenCoroutines/coro-dest-slot.cpp
+++ b/clang/test/CodeGenCoroutines/coro-dest-slot.cpp
@@ -1,8 +1,8 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -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 {
@@ -30,7 +30,7 @@
 // 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(
diff --git a/clang/test/CodeGenCoroutines/coro-dwarf.cpp b/clang/test/CodeGenCoroutines/coro-dwarf-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-dwarf.cpp
copy to clang/test/CodeGenCoroutines/coro-dwarf-exp-namespace.cpp
diff --git a/clang/test/CodeGenCoroutines/coro-dwarf.cpp b/clang/test/CodeGenCoroutines/coro-dwarf.cpp
--- a/clang/test/CodeGenCoroutines/coro-dwarf.cpp
+++ b/clang/test/CodeGenCoroutines/coro-dwarf.cpp
@@ -1,9 +1,9 @@
-// RUN: %clang_cc1 -disable-llvm-optzns -std=c++2a -fcoroutines-ts \
+// RUN: %clang_cc1 -disable-llvm-optzns -std=c++20 \
 // 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 {
@@ -16,15 +16,15 @@
   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;
diff --git a/clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp b/clang/test/CodeGenCoroutines/coro-eh-cleanup-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp
copy to clang/test/CodeGenCoroutines/coro-eh-cleanup-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp
+++ b/clang/test/CodeGenCoroutines/coro-eh-cleanup-exp-namespace.cpp
@@ -14,11 +14,11 @@
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-template <class Promise> struct coroutine_handle: coroutine_handle<void> {
+template <class Promise> struct coroutine_handle : coroutine_handle<void> {
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
-}
+} // namespace std::experimental
 
 struct suspend_always {
   bool await_ready() noexcept;
@@ -36,7 +36,9 @@
   };
 };
 
-struct Cleanup { ~Cleanup(); };
+struct Cleanup {
+  ~Cleanup();
+};
 void may_throw();
 
 coro_t f() {
diff --git a/clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp b/clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp
--- a/clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp
+++ b/clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp
@@ -1,7 +1,7 @@
-// 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
+// RUN: %clang_cc1 -std=c++20 -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++20 -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;
 };
@@ -18,11 +18,11 @@
   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;
 };
 
diff --git a/clang/test/CodeGenCoroutines/coro-gro.cpp b/clang/test/CodeGenCoroutines/coro-gro-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-gro.cpp
copy to clang/test/CodeGenCoroutines/coro-gro-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-gro.cpp
+++ b/clang/test/CodeGenCoroutines/coro-gro-exp-namespace.cpp
@@ -15,7 +15,7 @@
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std::experimental
 
 struct suspend_always {
   bool await_ready() noexcept;
@@ -40,7 +40,9 @@
   };
 };
 
-struct Cleanup { ~Cleanup(); };
+struct Cleanup {
+  ~Cleanup();
+};
 void doSomething() noexcept;
 
 // CHECK: define{{.*}} i32 @_Z1fv(
diff --git a/clang/test/CodeGenCoroutines/coro-gro-nrvo-exp-namespace.cpp b/clang/test/CodeGenCoroutines/coro-gro-nrvo-exp-namespace.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/CodeGenCoroutines/coro-gro-nrvo-exp-namespace.cpp
@@ -0,0 +1,85 @@
+// 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-exp-namespace.h"
+
+using namespace std::experimental;
+
+namespace std {
+
+struct nothrow_t {};
+constexpr nothrow_t nothrow = {};
+
+} // end namespace std
+
+// Required when get_return_object_on_allocation_failure() is defined by
+// the promise.
+void *operator new(__SIZE_TYPE__ __sz, const std::nothrow_t &) noexcept;
+void operator delete(void *__p, const std::nothrow_t &)noexcept;
+
+template <class RetObject>
+struct promise_type {
+  RetObject get_return_object();
+  suspend_always initial_suspend();
+  suspend_never final_suspend() noexcept;
+  void return_void();
+  static void unhandled_exception();
+};
+
+struct coro {
+  using promise_type = promise_type<coro>;
+  coro(coro const &);
+  struct Impl;
+  Impl *impl;
+};
+
+// Verify that the NRVO is applied to the Gro object.
+// CHECK-LABEL: define{{.*}} void @_Z1fi(%struct.coro* noalias sret(%struct.coro) align 8 %agg.result, i32 %0)
+coro f(int) {
+  // CHECK: %call = call noalias nonnull i8* @_Znwm(
+  // CHECK-NEXT: br label %[[CoroInit:.*]]
+
+  // CHECK: {{.*}}[[CoroInit]]:
+  // CHECK: store i1 false, i1* %gro.active
+  // CHECK: call void @{{.*get_return_objectEv}}(%struct.coro* sret(%struct.coro) align 8 %agg.result
+  // CHECK-NEXT: store i1 true, i1* %gro.active
+  co_return;
+}
+
+template <class RetObject>
+struct promise_type_with_on_alloc_failure {
+  static RetObject get_return_object_on_allocation_failure();
+  RetObject get_return_object();
+  suspend_always initial_suspend();
+  suspend_never final_suspend() noexcept;
+  void return_void();
+  static void unhandled_exception();
+};
+
+struct coro_two {
+  using promise_type = promise_type_with_on_alloc_failure<coro_two>;
+  coro_two(coro_two const &);
+  struct Impl;
+  Impl *impl;
+};
+
+// Verify that the NRVO is applied to the Gro object.
+// CHECK-LABEL: define{{.*}} void @_Z1hi(%struct.coro_two* noalias sret(%struct.coro_two) align 8 %agg.result, i32 %0)
+coro_two h(int) {
+
+  // CHECK: %call = call noalias i8* @_ZnwmRKSt9nothrow_t
+  // CHECK-NEXT: %[[CheckNull:.*]] = icmp ne i8* %call, null
+  // CHECK-NEXT: br i1 %[[CheckNull]], label %[[InitOnSuccess:.*]], label %[[InitOnFailure:.*]]
+
+  // CHECK: {{.*}}[[InitOnFailure]]:
+  // CHECK-NEXT: call void @{{.*get_return_object_on_allocation_failureEv}}(%struct.coro_two* sret(%struct.coro_two) align 8 %agg.result
+  // CHECK-NEXT: br label %[[RetLabel:.*]]
+
+  // CHECK: {{.*}}[[InitOnSuccess]]:
+  // CHECK: store i1 false, i1* %gro.active
+  // CHECK: call void @{{.*get_return_objectEv}}(%struct.coro_two* sret(%struct.coro_two) align 8 %agg.result
+  // CHECK-NEXT: store i1 true, i1* %gro.active
+
+  // CHECK: [[RetLabel]]:
+  // CHECK-NEXT: ret void
+  co_return;
+}
diff --git a/clang/test/CodeGenCoroutines/coro-gro-nrvo.cpp b/clang/test/CodeGenCoroutines/coro-gro-nrvo.cpp
--- a/clang/test/CodeGenCoroutines/coro-gro-nrvo.cpp
+++ b/clang/test/CodeGenCoroutines/coro-gro-nrvo.cpp
@@ -1,8 +1,8 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++20 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
 
 #include "Inputs/coroutine.h"
 
-using namespace std::experimental;
+using namespace std;
 
 namespace std {
 
diff --git a/clang/test/CodeGenCoroutines/coro-gro.cpp b/clang/test/CodeGenCoroutines/coro-gro.cpp
--- a/clang/test/CodeGenCoroutines/coro-gro.cpp
+++ b/clang/test/CodeGenCoroutines/coro-gro.cpp
@@ -1,8 +1,8 @@
 // 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
+// RUN: %clang_cc1 -std=c++20 -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 {
@@ -15,11 +15,11 @@
   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;
 };
 
@@ -28,7 +28,7 @@
   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;
@@ -51,8 +51,8 @@
   // 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;
@@ -60,12 +60,12 @@
   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]])
 
diff --git a/clang/test/CodeGenCoroutines/coro-lambda.cpp b/clang/test/CodeGenCoroutines/coro-lambda-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-lambda.cpp
copy to clang/test/CodeGenCoroutines/coro-lambda-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-lambda.cpp
+++ b/clang/test/CodeGenCoroutines/coro-lambda-exp-namespace.cpp
@@ -17,7 +17,7 @@
   coroutine_handle() = default;
   static coroutine_handle from_address(void *) noexcept;
 };
-}
+} // namespace std::experimental
 
 struct suspend_always {
   bool await_ready() noexcept;
@@ -38,7 +38,10 @@
 template <typename _AwrT> auto SyncAwait(_AwrT &&A) {
   if (!A.await_ready()) {
     auto AwaitAsync = [&]() -> Task {
-      try { (void)(co_await A); } catch (...) {}
+      try {
+        (void)(co_await A);
+      } catch (...) {
+      }
     };
     Task t = AwaitAsync();
   }
diff --git a/clang/test/CodeGenCoroutines/coro-lambda.cpp b/clang/test/CodeGenCoroutines/coro-lambda.cpp
--- a/clang/test/CodeGenCoroutines/coro-lambda.cpp
+++ b/clang/test/CodeGenCoroutines/coro-lambda.cpp
@@ -1,7 +1,7 @@
 // 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
+// RUN: %clang_cc1 -std=c++20 -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;
 };
@@ -17,11 +17,11 @@
   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;
 };
 
diff --git a/clang/test/CodeGenCoroutines/coro-newpm-pipeline.cpp b/clang/test/CodeGenCoroutines/coro-newpm-pipeline-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-newpm-pipeline.cpp
copy to clang/test/CodeGenCoroutines/coro-newpm-pipeline-exp-namespace.cpp
diff --git a/clang/test/CodeGenCoroutines/coro-newpm-pipeline.cpp b/clang/test/CodeGenCoroutines/coro-newpm-pipeline.cpp
--- a/clang/test/CodeGenCoroutines/coro-newpm-pipeline.cpp
+++ b/clang/test/CodeGenCoroutines/coro-newpm-pipeline.cpp
@@ -2,10 +2,10 @@
 // pipeline, at -O0 and above.
 
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm-bc -o /dev/null \
-// RUN:   -fexperimental-new-pass-manager -fdebug-pass-manager -fcoroutines-ts \
+// RUN:   -fexperimental-new-pass-manager -fdebug-pass-manager -std=c++20 \
 // RUN:   -O0 %s 2>&1 | FileCheck %s --check-prefixes=CHECK-ALL
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm-bc -o /dev/null \
-// RUN:   -fexperimental-new-pass-manager -fdebug-pass-manager -fcoroutines-ts \
+// RUN:   -fexperimental-new-pass-manager -fdebug-pass-manager -std=c++20 \
 // RUN:   -O1 %s 2>&1 | FileCheck %s --check-prefixes=CHECK-ALL,CHECK-OPT
 //
 // CHECK-ALL: Running pass:{{.*}}CoroEarlyPass
@@ -16,7 +16,6 @@
 // CHECK-ALL: Running pass:{{.*}}CoroCleanupPass
 
 namespace std {
-namespace experimental {
 
 struct handle {};
 
@@ -39,7 +38,6 @@
     void unhandled_exception() {}
   };
 };
-} // namespace experimental
 } // namespace std
 
 void foo() { co_return; }
diff --git a/clang/test/CodeGenCoroutines/coro-params.cpp b/clang/test/CodeGenCoroutines/coro-params-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-params.cpp
copy to clang/test/CodeGenCoroutines/coro-params-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-params.cpp
+++ b/clang/test/CodeGenCoroutines/coro-params-exp-namespace.cpp
@@ -17,7 +17,7 @@
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std::experimental
 
 struct suspend_always {
   bool await_ready() noexcept;
@@ -40,26 +40,26 @@
 // TODO: Not supported yet
 struct CopyOnly {
   int val;
-  CopyOnly(const CopyOnly&) noexcept;
-  CopyOnly(CopyOnly&&) = delete;
+  CopyOnly(const CopyOnly &) noexcept;
+  CopyOnly(CopyOnly &&) = delete;
   ~CopyOnly();
 };
 
 struct MoveOnly {
   int val;
-  MoveOnly(const MoveOnly&) = delete;
-  MoveOnly(MoveOnly&&) noexcept;
+  MoveOnly(const MoveOnly &) = delete;
+  MoveOnly(MoveOnly &&) noexcept;
   ~MoveOnly();
 };
 
 struct MoveAndCopy {
   int val;
-  MoveAndCopy(const MoveAndCopy&)noexcept;
-  MoveAndCopy(MoveAndCopy&&) noexcept;
+  MoveAndCopy(const MoveAndCopy &) noexcept;
+  MoveAndCopy(MoveAndCopy &&) noexcept;
   ~MoveAndCopy();
 };
 
-void consume(int,int,int) noexcept;
+void consume(int, int, int) noexcept;
 
 // TODO: Add support for CopyOnly params
 // CHECK: define{{.*}} void @_Z1fi8MoveOnly11MoveAndCopy(i32 %val, %struct.MoveOnly* %[[MoParam:.+]], %struct.MoveAndCopy* %[[McParam:.+]]) #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*
@@ -134,14 +134,16 @@
 struct A {
   int WontFitIntoRegisterForSure[128];
   A();
-  A(A&&) noexcept;
+  A(A &&)
+  noexcept;
   ~A();
 };
 
 struct B {
   int WontFitIntoRegisterForSure[128];
   B();
-  B(B&&) noexcept;
+  B(B &&)
+  noexcept;
   ~B();
 };
 
@@ -155,7 +157,7 @@
 
 struct promise_matching_constructor {};
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<void, promise_matching_constructor, int, float, double> {
   struct promise_type {
     promise_type(promise_matching_constructor, int, float, double) {}
@@ -183,7 +185,7 @@
 
 template <typename... Args> struct std::experimental::coroutine_traits<method, Args...> {
   struct promise_type {
-    promise_type(some_class&, float);
+    promise_type(some_class &, float);
     method get_return_object();
     suspend_always initial_suspend();
     suspend_always final_suspend() noexcept;
diff --git a/clang/test/CodeGenCoroutines/coro-params.cpp b/clang/test/CodeGenCoroutines/coro-params.cpp
--- a/clang/test/CodeGenCoroutines/coro-params.cpp
+++ b/clang/test/CodeGenCoroutines/coro-params.cpp
@@ -2,9 +2,9 @@
 // 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
+// RUN: %clang_cc1 -std=c++20 -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 {
@@ -17,15 +17,15 @@
   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;
@@ -73,9 +73,9 @@
   // 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* %{{.*}}
@@ -89,12 +89,12 @@
   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*
@@ -124,9 +124,9 @@
   // 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;
 }
@@ -155,8 +155,8 @@
 
 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;
@@ -173,7 +173,7 @@
   // 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;
 }
 
@@ -181,7 +181,7 @@
 
 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();
@@ -198,6 +198,6 @@
 
 // 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;
 }
diff --git a/clang/test/CodeGenCoroutines/coro-promise-dtor.cpp b/clang/test/CodeGenCoroutines/coro-promise-dtor-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-promise-dtor.cpp
copy to clang/test/CodeGenCoroutines/coro-promise-dtor-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-promise-dtor.cpp
+++ b/clang/test/CodeGenCoroutines/coro-promise-dtor-exp-namespace.cpp
@@ -1,12 +1,12 @@
 // 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"
+#include "Inputs/coroutine-exp-namespace.h"
 
 namespace coro = std::experimental::coroutines_v1;
 
 struct coro_t {
-  void* p;
+  void *p;
   ~coro_t();
   struct promise_type {
     coro_t get_return_object();
@@ -19,7 +19,9 @@
   };
 };
 
-struct Cleanup { ~Cleanup(); };
+struct Cleanup {
+  ~Cleanup();
+};
 void may_throw();
 
 coro_t f() {
diff --git a/clang/test/CodeGenCoroutines/coro-promise-dtor.cpp b/clang/test/CodeGenCoroutines/coro-promise-dtor.cpp
--- a/clang/test/CodeGenCoroutines/coro-promise-dtor.cpp
+++ b/clang/test/CodeGenCoroutines/coro-promise-dtor.cpp
@@ -1,17 +1,15 @@
-// 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
+// RUN: %clang_cc1 -std=c++20 -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();
diff --git a/clang/test/CodeGenCoroutines/coro-ret-void.cpp b/clang/test/CodeGenCoroutines/coro-ret-void-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-ret-void.cpp
copy to clang/test/CodeGenCoroutines/coro-ret-void-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-ret-void.cpp
+++ b/clang/test/CodeGenCoroutines/coro-ret-void-exp-namespace.cpp
@@ -1,6 +1,6 @@
 // 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"
+#include "Inputs/coroutine-exp-namespace.h"
 
 namespace coro = std::experimental::coroutines_v1;
 
@@ -27,7 +27,7 @@
 };
 
 coro1 f2() {
-  co_return (void) A{};
+  co_return(void) A{};
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z2f2v(
diff --git a/clang/test/CodeGenCoroutines/coro-ret-void.cpp b/clang/test/CodeGenCoroutines/coro-ret-void.cpp
--- a/clang/test/CodeGenCoroutines/coro-ret-void.cpp
+++ b/clang/test/CodeGenCoroutines/coro-ret-void.cpp
@@ -1,24 +1,22 @@
-// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
+// RUN: %clang_cc1 -std=c++20 -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 {
@@ -38,8 +36,8 @@
 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);
   };
 };
@@ -49,5 +47,5 @@
 }
 
 // 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)
diff --git a/clang/test/CodeGenCoroutines/coro-return.cpp b/clang/test/CodeGenCoroutines/coro-return-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-return.cpp
copy to clang/test/CodeGenCoroutines/coro-return-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-return.cpp
+++ b/clang/test/CodeGenCoroutines/coro-return-exp-namespace.cpp
@@ -13,7 +13,7 @@
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept {}
 };
-}
+} // namespace std::experimental
 
 struct suspend_always {
   bool await_ready() noexcept;
@@ -39,7 +39,7 @@
   co_return;
 }
 
-template<>
+template <>
 struct std::experimental::coroutine_traits<int> {
   struct promise_type {
     int get_return_object();
diff --git a/clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp b/clang/test/CodeGenCoroutines/coro-return-voidtype-initlist-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp
copy to clang/test/CodeGenCoroutines/coro-return-voidtype-initlist-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp
+++ b/clang/test/CodeGenCoroutines/coro-return-voidtype-initlist-exp-namespace.cpp
@@ -73,7 +73,7 @@
   std::c<int> bu;
   int bw(0);
   // CHECK: void @_ZN1j12return_valueESt1bISt1cIiiEE(%struct.j* {{[^,]*}} %__promise)
-  co_return{0, co_await ax(bu, bw)};
+  co_return {0, co_await ax(bu, bw)};
 }
 void bh() {
   auto cn = [] { J<int>::bo; };
diff --git a/clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp b/clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp
--- a/clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp
+++ b/clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp
@@ -1,11 +1,10 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++1z -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -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>
@@ -21,7 +20,6 @@
   void await_suspend(coroutine_handle<>);
   void await_resume();
 };
-} // namespace experimental
 } // namespace std
 template <typename ag>
 auto ah(ag) { return ag().ah(0); }
@@ -31,10 +29,10 @@
   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()); }
@@ -45,20 +43,20 @@
   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); }
diff --git a/clang/test/CodeGenCoroutines/coro-return.cpp b/clang/test/CodeGenCoroutines/coro-return.cpp
--- a/clang/test/CodeGenCoroutines/coro-return.cpp
+++ b/clang/test/CodeGenCoroutines/coro-return.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++1z -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -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 {
@@ -13,15 +13,15 @@
   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();
@@ -32,15 +32,15 @@
 
 // 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();
@@ -51,9 +51,9 @@
 
 // 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;
 }
diff --git a/clang/test/CodeGenCoroutines/coro-symmetric-transfer-01.cpp b/clang/test/CodeGenCoroutines/coro-symmetric-transfer-01-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-symmetric-transfer-01.cpp
copy to clang/test/CodeGenCoroutines/coro-symmetric-transfer-01-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-symmetric-transfer-01.cpp
+++ b/clang/test/CodeGenCoroutines/coro-symmetric-transfer-01-exp-namespace.cpp
@@ -1,7 +1,7 @@
 // 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"
+#include "Inputs/coroutine-exp-namespace.h"
 
 namespace coro = std::experimental::coroutines_v1;
 
diff --git a/clang/test/CodeGenCoroutines/coro-symmetric-transfer-01.cpp b/clang/test/CodeGenCoroutines/coro-symmetric-transfer-01.cpp
--- a/clang/test/CodeGenCoroutines/coro-symmetric-transfer-01.cpp
+++ b/clang/test/CodeGenCoroutines/coro-symmetric-transfer-01.cpp
@@ -1,21 +1,19 @@
-// 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
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -O0 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
+// RUN: %clang -std=c++20 -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 {};
       }
@@ -26,7 +24,7 @@
 
     final_awaiter final_suspend() noexcept { return {}; }
 
-    coro::suspend_always initial_suspend() noexcept { return {}; }
+    std::suspend_always initial_suspend() noexcept { return {}; }
   };
 
   ~detached_task() {
@@ -42,7 +40,7 @@
     tmp.resume();
   }
 
-  coro::coroutine_handle<promise_type> coro_;
+  std::coroutine_handle<promise_type> coro_;
 };
 
 detached_task foo() {
@@ -52,12 +50,12 @@
 // check that the lifetime of the coroutine handle used to obtain the address is contained within single basic block, and hence does not live across suspension points.
 // CHECK-LABEL: final.suspend:
 // CHECK:         %{{.+}} = call token @llvm.coro.save(i8* null)
-// CHECK:         %[[HDL_CAST1:.+]] = bitcast %"struct.std::experimental::coroutines_v1::coroutine_handle.0"* %[[HDL:.+]] to i8*
+// CHECK:         %[[HDL_CAST1:.+]] = bitcast %"struct.std::coroutine_handle.0"* %[[HDL:.+]] to i8*
 // CHECK:         call void @llvm.lifetime.start.p0i8(i64 8, i8* %[[HDL_CAST1]])
-// CHECK:         %[[CALL:.+]] = call i8* @_ZN13detached_task12promise_type13final_awaiter13await_suspendENSt12experimental13coroutines_v116coroutine_handleIS0_EE(
-// CHECK:         %[[HDL_CAST2:.+]] = getelementptr inbounds %"struct.std::experimental::coroutines_v1::coroutine_handle.0", %"struct.std::experimental::coroutines_v1::coroutine_handle.0"* %[[HDL]], i32 0, i32 0
+// CHECK:         %[[CALL:.+]] = call i8* @_ZN13detached_task12promise_type13final_awaiter13await_suspendESt16coroutine_handleIS0_E(
+// CHECK:         %[[HDL_CAST2:.+]] = getelementptr inbounds %"struct.std::coroutine_handle.0", %"struct.std::coroutine_handle.0"* %[[HDL]], i32 0, i32 0
 // CHECK:         store i8* %[[CALL]], i8** %[[HDL_CAST2]], align 8
-// CHECK:         %[[HDL_TRANSFER:.+]] = call i8* @_ZNKSt12experimental13coroutines_v116coroutine_handleIvE7addressEv(%"struct.std::experimental::coroutines_v1::coroutine_handle.0"* nonnull align 8 dereferenceable(8) %[[HDL]])
-// CHECK:         %[[HDL_CAST3:.+]] = bitcast %"struct.std::experimental::coroutines_v1::coroutine_handle.0"* %[[HDL]] to i8*
+// CHECK:         %[[HDL_TRANSFER:.+]] = call i8* @_ZNKSt16coroutine_handleIvE7addressEv(%"struct.std::coroutine_handle.0"* {{.*}}%[[HDL]])
+// CHECK:         %[[HDL_CAST3:.+]] = bitcast %"struct.std::coroutine_handle.0"* %[[HDL]] to i8*
 // CHECK:         call void @llvm.lifetime.end.p0i8(i64 8, i8* %[[HDL_CAST3]])
 // CHECK:         call void @llvm.coro.resume(i8* %[[HDL_TRANSFER]])
diff --git a/clang/test/CodeGenCoroutines/coro-symmetric-transfer-02.cpp b/clang/test/CodeGenCoroutines/coro-symmetric-transfer-02-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-symmetric-transfer-02.cpp
copy to clang/test/CodeGenCoroutines/coro-symmetric-transfer-02-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-symmetric-transfer-02.cpp
+++ b/clang/test/CodeGenCoroutines/coro-symmetric-transfer-02-exp-namespace.cpp
@@ -1,6 +1,6 @@
 // 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"
+#include "Inputs/coroutine-exp-namespace.h"
 
 namespace coro = std::experimental::coroutines_v1;
 
diff --git a/clang/test/CodeGenCoroutines/coro-symmetric-transfer-02.cpp b/clang/test/CodeGenCoroutines/coro-symmetric-transfer-02.cpp
--- a/clang/test/CodeGenCoroutines/coro-symmetric-transfer-02.cpp
+++ b/clang/test/CodeGenCoroutines/coro-symmetric-transfer-02.cpp
@@ -1,20 +1,18 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -O1 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -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 {};
       }
@@ -25,7 +23,7 @@
 
     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) {
@@ -33,7 +31,7 @@
     }
   };
 
-  using handle_t = coro::coroutine_handle<promise_type>;
+  using handle_t = std::coroutine_handle<promise_type>;
 
   class Awaiter {
   public:
@@ -43,7 +41,7 @@
     ~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:
@@ -91,10 +89,10 @@
 // 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
@@ -110,10 +108,10 @@
 // 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
diff --git a/clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp b/clang/test/CodeGenCoroutines/coro-unhandled-exception-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp
copy to clang/test/CodeGenCoroutines/coro-unhandled-exception-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp
+++ b/clang/test/CodeGenCoroutines/coro-unhandled-exception-exp-namespace.cpp
@@ -1,14 +1,14 @@
 // 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"
+#include "Inputs/coroutine-exp-namespace.h"
 
 namespace coro = std::experimental::coroutines_v1;
 
 namespace std {
-  using exception_ptr = int;
-  exception_ptr current_exception();
-}
+using exception_ptr = int;
+exception_ptr current_exception();
+} // namespace std
 
 struct coro_t {
   struct promise_type {
@@ -18,12 +18,14 @@
     }
     coro::suspend_never initial_suspend() { return {}; }
     coro::suspend_never final_suspend() noexcept { return {}; }
-    void return_void(){}
+    void return_void() {}
     void unhandled_exception() noexcept;
   };
 };
 
-struct Cleanup { ~Cleanup(); };
+struct Cleanup {
+  ~Cleanup();
+};
 void may_throw();
 
 coro_t f() {
diff --git a/clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp b/clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp
--- a/clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp
+++ b/clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp
@@ -1,10 +1,8 @@
-// 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
+// RUN: %clang_cc1 -std=c++20 -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++20 -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();
@@ -13,11 +11,11 @@
 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;
   };
@@ -50,9 +48,9 @@
 // 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()
@@ -71,6 +69,6 @@
 // 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(
diff --git a/clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait.cpp b/clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait-exp-namespace.cpp
copy from clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait.cpp
copy to clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait-exp-namespace.cpp
--- a/clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait.cpp
+++ b/clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait-exp-namespace.cpp
@@ -11,7 +11,7 @@
 
 struct B {};
 
-no_suspend operator co_await(B const&) { return {}; }
+no_suspend operator co_await(B const &) { return {}; }
 
 // CHECK-LABEL: f(
 extern "C" void f() {
@@ -22,4 +22,3 @@
   // CHECK-NEXT: call i8 @"??__L@YA?AUno_suspend@@AEBUB@@@Z"(
   operator co_await(b);
 }
-
diff --git a/clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait.cpp b/clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait.cpp
--- a/clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait.cpp
+++ b/clang/test/CodeGenCoroutines/microsoft-abi-operator-coawait.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -triple x86_64-pc-windows-msvc18.0.0 -fcoroutines-ts -emit-llvm %s -o - -std=c++14 -disable-llvm-passes | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-pc-windows-msvc18.0.0 -emit-llvm %s -o - -std=c++20 -disable-llvm-passes | FileCheck %s
 struct no_suspend {
   bool await_ready() { return true; }
   template <typename F> void await_suspend(F) {}
diff --git a/clang/test/CoverageMapping/coroutine.cpp b/clang/test/CoverageMapping/coroutine.cpp
--- a/clang/test/CoverageMapping/coroutine.cpp
+++ b/clang/test/CoverageMapping/coroutine.cpp
@@ -1,6 +1,6 @@
 // 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;
 
@@ -16,16 +16,16 @@
   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();
diff --git a/clang/test/Index/coroutines.cpp b/clang/test/Index/coroutines.cpp
--- a/clang/test/Index/coroutines.cpp
+++ b/clang/test/Index/coroutines.cpp
@@ -1,8 +1,8 @@
 // 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();
@@ -13,7 +13,7 @@
 };
 
 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;
diff --git a/clang/test/Lexer/cxx-features.cpp b/clang/test/Lexer/cxx-features.cpp
--- a/clang/test/Lexer/cxx-features.cpp
+++ b/clang/test/Lexer/cxx-features.cpp
@@ -95,6 +95,10 @@
 #error "wrong value for __cpp_impl_three_way_comparison"
 #endif
 
+#if check(impl_coroutine, 0, 0, 0, 0, 201902L, 201902L)
+#error "wrong value for __cpp_impl_coroutine"
+#endif
+
 // init_captures checked below
 
 #if check(modules, 0, 0, 0, 0, 0, 0)
diff --git a/clang/test/PCH/coroutines.cpp b/clang/test/PCH/coroutines.cpp
--- a/clang/test/PCH/coroutines.cpp
+++ b/clang/test/PCH/coroutines.cpp
@@ -8,7 +8,7 @@
 #ifndef HEADER
 #define HEADER
 
-namespace std::experimental {
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
@@ -21,15 +21,15 @@
   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;
@@ -42,7 +42,7 @@
   };
 };
 
-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;
diff --git a/clang/test/SemaCXX/Inputs/std-coroutine.h b/clang/test/SemaCXX/Inputs/std-coroutine-exp-namespace.h
copy from clang/test/SemaCXX/Inputs/std-coroutine.h
copy to clang/test/SemaCXX/Inputs/std-coroutine-exp-namespace.h
--- a/clang/test/SemaCXX/Inputs/std-coroutine.h
+++ b/clang/test/SemaCXX/Inputs/std-coroutine-exp-namespace.h
@@ -1,10 +1,9 @@
 // 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
+#ifndef STD_COROUTINE_EXPERIMENTAL_H
+#define STD_COROUTINE_EXPERIMENTAL_H
 
 namespace std {
 namespace experimental {
-
 template <class Ret, typename... T>
 struct coroutine_traits { using promise_type = typename Ret::promise_type; };
 
@@ -30,8 +29,7 @@
   void await_suspend(coroutine_handle<>) noexcept {}
   void await_resume() noexcept {}
 };
-
 } // namespace experimental
 } // namespace std
 
-#endif // STD_COROUTINE_H
+#endif // STD_COROUTINE_EXPERIMENTAL_H
diff --git a/clang/test/SemaCXX/Inputs/std-coroutine.h b/clang/test/SemaCXX/Inputs/std-coroutine.h
--- a/clang/test/SemaCXX/Inputs/std-coroutine.h
+++ b/clang/test/SemaCXX/Inputs/std-coroutine.h
@@ -1,9 +1,8 @@
-// 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
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 -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; };
@@ -31,7 +30,6 @@
   void await_resume() noexcept {}
 };
 
-} // namespace experimental
 } // namespace std
 
 #endif // STD_COROUTINE_H
diff --git a/clang/test/SemaCXX/co_await-range-for.cpp b/clang/test/SemaCXX/co_await-range-for-exp-namespace.cpp
copy from clang/test/SemaCXX/co_await-range-for.cpp
copy to clang/test/SemaCXX/co_await-range-for-exp-namespace.cpp
--- a/clang/test/SemaCXX/co_await-range-for.cpp
+++ b/clang/test/SemaCXX/co_await-range-for-exp-namespace.cpp
@@ -1,11 +1,10 @@
 // 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"
+#include "Inputs/std-coroutine-exp-namespace.h"
 
 using namespace std::experimental;
 
-
 template <class Begin>
 struct Awaiter {
   bool await_ready();
@@ -51,7 +50,8 @@
 };
 MyForLoopArrayAwaiter g() {
   int arr[10] = {0};
-  for co_await(auto i : arr) {}
+  for
+    co_await(auto i : arr) {}
   // expected-error@-1 {{call to deleted member function 'await_transform'}}
   // expected-note@-2 {{'await_transform' implicitly required by 'co_await' here}}
 }
@@ -73,14 +73,16 @@
 };
 ForLoopAwaiterBadBeginTransform bad_begin() {
   Range<int> R;
-  for co_await(auto i : R) {}
+  for
+    co_await(auto i : R) {}
   // expected-error@-1 {{call to deleted member function 'await_transform'}}
   // expected-note@-2 {{'await_transform' implicitly required by 'co_await' here}}
 }
 template <class Dummy>
 ForLoopAwaiterBadBeginTransform bad_begin_template(Dummy) {
   Range<Dummy> R;
-  for co_await(auto i : R) {}
+  for
+    co_await(auto i : R) {}
   // expected-error@-1 {{call to deleted member function 'await_transform'}}
   // expected-note@-2 {{'await_transform' implicitly required by 'co_await' here}}
 }
@@ -107,7 +109,8 @@
 };
 ForLoopAwaiterBadIncTransform bad_inc_transform() {
   Range<float> R;
-  for co_await(auto i : R) {}
+  for
+    co_await(auto i : R) {}
   // expected-error@-1 {{overload resolution selected deleted operator 'co_await'}}
   // expected-note@-2 {{in implicit call to 'operator++' for iterator of type 'Range<float>'}}
 }
@@ -115,7 +118,8 @@
 template <class Dummy>
 ForLoopAwaiterBadIncTransform bad_inc_transform_template(Dummy) {
   Range<Dummy> R;
-  for co_await(auto i : R) {}
+  for
+    co_await(auto i : R) {}
   // expected-error@-1 {{overload resolution selected deleted operator 'co_await'}}
   // expected-note@-2 {{in implicit call to 'operator++' for iterator of type 'Range<long>'}}
 }
@@ -126,7 +130,8 @@
 template <class T>
 constexpr void never_instant(T) {
   static_assert(sizeof(T) != sizeof(T), "function should not be instantiated");
-  for co_await(auto i : foo(T{})) {}
+  for
+    co_await(auto i : foo(T{})) {}
   // expected-error@-1 {{'co_await' cannot be used in a constexpr function}}
 }
 
@@ -150,7 +155,8 @@
 template <class T>
 ForLoopAwaiterCoawaitLookup test_coawait_lookup(T) {
   Range<T> R;
-  for co_await(auto i : R) {}
+  for
+    co_await(auto i : R) {}
   // expected-error@-1 {{no member named 'await_ready' in 'CoawaitTag<Iter<int>, false>'}}
 }
 template ForLoopAwaiterCoawaitLookup test_coawait_lookup(int); // expected-note {{requested here}}
diff --git a/clang/test/SemaCXX/co_await-range-for.cpp b/clang/test/SemaCXX/co_await-range-for.cpp
--- a/clang/test/SemaCXX/co_await-range-for.cpp
+++ b/clang/test/SemaCXX/co_await-range-for.cpp
@@ -1,10 +1,9 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 \
 // 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 {
diff --git a/clang/test/SemaCXX/coreturn-eh.cpp b/clang/test/SemaCXX/coreturn-eh-exp-namespace.cpp
copy from clang/test/SemaCXX/coreturn-eh.cpp
copy to clang/test/SemaCXX/coreturn-eh-exp-namespace.cpp
--- a/clang/test/SemaCXX/coreturn-eh.cpp
+++ b/clang/test/SemaCXX/coreturn-eh-exp-namespace.cpp
@@ -1,7 +1,7 @@
 // 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"
+#include "Inputs/std-coroutine-exp-namespace.h"
 
 using std::experimental::suspend_always;
 using std::experimental::suspend_never;
@@ -12,7 +12,9 @@
   void await_resume();
 } a;
 
-struct object { ~object() {} };
+struct object {
+  ~object() {}
+};
 
 struct promise_void_return_value {
   void get_return_object();
diff --git a/clang/test/SemaCXX/coreturn-eh.cpp b/clang/test/SemaCXX/coreturn-eh.cpp
--- a/clang/test/SemaCXX/coreturn-eh.cpp
+++ b/clang/test/SemaCXX/coreturn-eh.cpp
@@ -1,14 +1,14 @@
-// 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
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 -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;
 
@@ -33,7 +33,7 @@
 };
 
 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 = {};
diff --git a/clang/test/SemaCXX/coreturn.cpp b/clang/test/SemaCXX/coreturn-exp-namespace.cpp
copy from clang/test/SemaCXX/coreturn.cpp
copy to clang/test/SemaCXX/coreturn-exp-namespace.cpp
--- a/clang/test/SemaCXX/coreturn.cpp
+++ b/clang/test/SemaCXX/coreturn-exp-namespace.cpp
@@ -1,5 +1,5 @@
 // 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"
+#include "Inputs/std-coroutine-exp-namespace.h"
 
 using std::experimental::suspend_always;
 using std::experimental::suspend_never;
diff --git a/clang/test/SemaCXX/coreturn.cpp b/clang/test/SemaCXX/coreturn.cpp
--- a/clang/test/SemaCXX/coreturn.cpp
+++ b/clang/test/SemaCXX/coreturn.cpp
@@ -1,12 +1,12 @@
-// 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
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 -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;
 
@@ -72,16 +72,16 @@
 };
 
 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; }
diff --git a/clang/test/SemaCXX/coroutine-builtins.cpp b/clang/test/SemaCXX/coroutine-builtins.cpp
--- a/clang/test/SemaCXX/coroutine-builtins.cpp
+++ b/clang/test/SemaCXX/coroutine-builtins.cpp
@@ -1,7 +1,8 @@
 // RUN: %clang_cc1 -fsyntax-only -verify -fcoroutines-ts %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -DERRORS %s
 
-// Check that we don't crash when using __builtin_coro_* without the fcoroutine-ts option
+// Check that we don't crash when using __builtin_coro_* without the fcoroutine-ts or -std=c++20 option
 
 #ifdef ERRORS
 // expected-error@#A{{use of undeclared identifier '__builtin_coro_done'}}
diff --git a/clang/test/SemaCXX/coroutine-final-suspend-noexcept.cpp b/clang/test/SemaCXX/coroutine-final-suspend-noexcept-exp-namespace.cpp
copy from clang/test/SemaCXX/coroutine-final-suspend-noexcept.cpp
copy to clang/test/SemaCXX/coroutine-final-suspend-noexcept-exp-namespace.cpp
--- a/clang/test/SemaCXX/coroutine-final-suspend-noexcept.cpp
+++ b/clang/test/SemaCXX/coroutine-final-suspend-noexcept-exp-namespace.cpp
@@ -5,7 +5,6 @@
 
 namespace std {
 namespace experimental {
-
 template <class Ret, typename... T>
 struct coroutine_traits { using promise_type = typename Ret::promise_type; };
 
@@ -33,11 +32,10 @@
   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();
@@ -49,8 +47,8 @@
 struct coro_t {
   struct promise_type {
     coro_t get_return_object();
-    suspend_never initial_suspend();
-    suspend_always final_suspend(); // expected-note 2 {{must be declared with 'noexcept'}}
+    std::experimental::suspend_never initial_suspend();
+    std::experimental::suspend_always final_suspend(); // expected-note 2 {{must be declared with 'noexcept'}}
     void return_void();
     static void unhandled_exception();
   };
diff --git a/clang/test/SemaCXX/coroutine-final-suspend-noexcept.cpp b/clang/test/SemaCXX/coroutine-final-suspend-noexcept.cpp
--- a/clang/test/SemaCXX/coroutine-final-suspend-noexcept.cpp
+++ b/clang/test/SemaCXX/coroutine-final-suspend-noexcept.cpp
@@ -1,10 +1,9 @@
 // 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
+// RUN: %clang_cc1 -std=c++20 -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; };
@@ -34,10 +33,9 @@
   ~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();
diff --git a/clang/test/SemaCXX/coroutine-mixed-exp-namespace.cpp b/clang/test/SemaCXX/coroutine-mixed-exp-namespace.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/SemaCXX/coroutine-mixed-exp-namespace.cpp
@@ -0,0 +1,27 @@
+// This file is to test the mixed use of `std::experimental::coroutine*` and `std::coroutine*`
+// wouldn't make the compliler to crash and emit the diagnostic message correctly.
+// RUN: %clang_cc1 -verify -std=c++20 -fsyntax-only %s
+
+#include "Inputs/std-coroutine-exp-namespace.h"
+#include "Inputs/std-coroutine.h"
+
+struct my_awaitable {
+  bool await_ready() noexcept;
+  void await_suspend(std::experimental::coroutine_handle<> coro) noexcept;
+  void await_resume() noexcept;
+};
+
+struct promise_void {
+  void get_return_object();
+  my_awaitable initial_suspend();
+  my_awaitable final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+template <>
+struct std::coroutine_traits<void> { using promise_type = promise_void; };
+
+void test() {
+  co_return; // expected-error {{Found mixed use of std namespace and std::experimental namespace for coroutine, which is disallowed. The coroutine components in std::experimental namespace is deprecated. Please use coroutine components under std namespace.}}
+}
diff --git a/clang/test/SemaCXX/coroutine-mixed2-exp-namespace.cpp b/clang/test/SemaCXX/coroutine-mixed2-exp-namespace.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/SemaCXX/coroutine-mixed2-exp-namespace.cpp
@@ -0,0 +1,28 @@
+// This file is to test the mixed use of `std::experimental::coroutine*` and `std::coroutine*`
+// which is similar to coroutine-mixed-exp-namesapce. This file tests the relative order of
+// included header wouldn't affect the diagnostic messages.
+// RUN: %clang_cc1 -verify -std=c++20 -fsyntax-only %s
+
+#include "Inputs/std-coroutine-exp-namespace.h"
+#include "Inputs/std-coroutine.h"
+
+struct my_awaitable {
+  bool await_ready() noexcept;
+  void await_suspend(std::experimental::coroutine_handle<> coro) noexcept;
+  void await_resume() noexcept;
+};
+
+struct promise_void {
+  void get_return_object();
+  my_awaitable initial_suspend();
+  my_awaitable final_suspend() noexcept;
+  void return_void();
+  void unhandled_exception();
+};
+
+template <>
+struct std::coroutine_traits<void> { using promise_type = promise_void; };
+
+void test() {
+  co_return; // expected-error {{Found mixed use of std namespace and std::experimental namespace for coroutine, which is disallowed. The coroutine components in std::experimental namespace is deprecated. Please use coroutine components under std namespace.}}
+}
diff --git a/clang/test/SemaCXX/coroutine-rvo.cpp b/clang/test/SemaCXX/coroutine-rvo-exp-namespace.cpp
copy from clang/test/SemaCXX/coroutine-rvo.cpp
copy to clang/test/SemaCXX/coroutine-rvo-exp-namespace.cpp
--- a/clang/test/SemaCXX/coroutine-rvo.cpp
+++ b/clang/test/SemaCXX/coroutine-rvo-exp-namespace.cpp
@@ -30,7 +30,7 @@
 
 template <class Ret, class... Args>
 struct coroutine_traits : public traits_sfinae_base<Ret> {};
-}
+} // namespace std::experimental
 
 struct suspend_never {
   bool await_ready() noexcept;
@@ -40,7 +40,7 @@
 
 struct MoveOnly {
   MoveOnly() = default;
-  MoveOnly(const MoveOnly&) = delete;
+  MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
 };
 
diff --git a/clang/test/SemaCXX/coroutine-rvo.cpp b/clang/test/SemaCXX/coroutine-rvo.cpp
--- a/clang/test/SemaCXX/coroutine-rvo.cpp
+++ b/clang/test/SemaCXX/coroutine-rvo.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -verify -std=c++17 -fcoroutines-ts -fsyntax-only %s
+// RUN: %clang_cc1 -verify -std=c++20 -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;
@@ -30,11 +30,11 @@
 
 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;
 };
 
diff --git a/clang/test/SemaCXX/coroutine-seh.cpp b/clang/test/SemaCXX/coroutine-seh-exp-namespace.cpp
copy from clang/test/SemaCXX/coroutine-seh.cpp
copy to clang/test/SemaCXX/coroutine-seh-exp-namespace.cpp
--- a/clang/test/SemaCXX/coroutine-seh.cpp
+++ b/clang/test/SemaCXX/coroutine-seh-exp-namespace.cpp
@@ -12,7 +12,7 @@
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 };
-}
+} // namespace std::experimental
 
 struct suspend_always {
   bool await_ready() noexcept;
@@ -31,7 +31,8 @@
 };
 
 void SEH_used() {
-  __try { // expected-error {{cannot use SEH '__try' in a coroutine when C++ exceptions are enabled}}
+  __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) {}
+  } __except (0) {
+  }
 }
diff --git a/clang/test/SemaCXX/coroutine-seh.cpp b/clang/test/SemaCXX/coroutine-seh.cpp
--- a/clang/test/SemaCXX/coroutine-seh.cpp
+++ b/clang/test/SemaCXX/coroutine-seh.cpp
@@ -1,5 +1,5 @@
-// RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -verify %s -fcxx-exceptions -fexceptions -triple x86_64-windows-msvc -fms-extensions
-namespace std::experimental {
+// RUN: %clang_cc1 -std=c++20 -verify %s -fcxx-exceptions -fexceptions -triple x86_64-windows-msvc -fms-extensions
+namespace std {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
@@ -12,15 +12,15 @@
   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;
diff --git a/clang/test/SemaCXX/coroutine-traits-undefined-template.cpp b/clang/test/SemaCXX/coroutine-traits-undefined-template-exp-namespace.cpp
copy from clang/test/SemaCXX/coroutine-traits-undefined-template.cpp
copy to clang/test/SemaCXX/coroutine-traits-undefined-template-exp-namespace.cpp
--- a/clang/test/SemaCXX/coroutine-traits-undefined-template.cpp
+++ b/clang/test/SemaCXX/coroutine-traits-undefined-template-exp-namespace.cpp
@@ -5,14 +5,14 @@
 
 namespace std {
 namespace experimental {
-
-template<typename ...T>
+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::experimental::coroutine_traits<void>'}}
+} // namespace experimental
+} // namespace std
 
 void uses_forward_declaration() {
   co_return; // expected-error {{this function cannot be a coroutine: missing definition of specialization 'coroutine_traits<void>'}}
diff --git a/clang/test/SemaCXX/coroutine-traits-undefined-template.cpp b/clang/test/SemaCXX/coroutine-traits-undefined-template.cpp
--- a/clang/test/SemaCXX/coroutine-traits-undefined-template.cpp
+++ b/clang/test/SemaCXX/coroutine-traits-undefined-template.cpp
@@ -1,18 +1,17 @@
 // 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
+// RUN: %clang_cc1 -std=c++20 -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>'}}
diff --git a/clang/test/SemaCXX/coroutine-unhandled_exception-warning.cpp b/clang/test/SemaCXX/coroutine-unhandled_exception-warning-exp-namespace.cpp
copy from clang/test/SemaCXX/coroutine-unhandled_exception-warning.cpp
copy to clang/test/SemaCXX/coroutine-unhandled_exception-warning-exp-namespace.cpp
--- a/clang/test/SemaCXX/coroutine-unhandled_exception-warning.cpp
+++ b/clang/test/SemaCXX/coroutine-unhandled_exception-warning-exp-namespace.cpp
@@ -11,7 +11,7 @@
 #error This test requires exceptions be disabled
 #endif
 
-#include "Inputs/std-coroutine.h"
+#include "Inputs/std-coroutine-exp-namespace.h"
 
 using std::experimental::suspend_always;
 using std::experimental::suspend_never;
diff --git a/clang/test/SemaCXX/coroutine-unhandled_exception-warning.cpp b/clang/test/SemaCXX/coroutine-unhandled_exception-warning.cpp
--- a/clang/test/SemaCXX/coroutine-unhandled_exception-warning.cpp
+++ b/clang/test/SemaCXX/coroutine-unhandled_exception-warning.cpp
@@ -1,8 +1,8 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts \
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 \
 // 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: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 \
 // 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
@@ -13,8 +13,8 @@
 
 #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}}
@@ -28,7 +28,7 @@
 };
 
 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}}
diff --git a/clang/test/SemaCXX/coroutine-uninitialized-warning-crash.cpp b/clang/test/SemaCXX/coroutine-uninitialized-warning-crash-exp-namespace.cpp
copy from clang/test/SemaCXX/coroutine-uninitialized-warning-crash.cpp
copy to clang/test/SemaCXX/coroutine-uninitialized-warning-crash-exp-namespace.cpp
--- a/clang/test/SemaCXX/coroutine-uninitialized-warning-crash.cpp
+++ b/clang/test/SemaCXX/coroutine-uninitialized-warning-crash-exp-namespace.cpp
@@ -1,9 +1,8 @@
 // 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"
+#include "Inputs/std-coroutine-exp-namespace.h"
 
 using namespace std::experimental;
 
-
 struct A {
   bool await_ready() { return true; }
   int await_resume() { return 42; }
@@ -11,7 +10,6 @@
   void await_suspend(F) {}
 };
 
-
 struct coro_t {
   struct promise_type {
     coro_t get_return_object() { return {}; }
diff --git a/clang/test/SemaCXX/coroutine-uninitialized-warning-crash.cpp b/clang/test/SemaCXX/coroutine-uninitialized-warning-crash.cpp
--- a/clang/test/SemaCXX/coroutine-uninitialized-warning-crash.cpp
+++ b/clang/test/SemaCXX/coroutine-uninitialized-warning-crash.cpp
@@ -1,8 +1,7 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wall -Wextra -Wuninitialized  -fblocks
+// RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++20 -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; }
diff --git a/clang/test/SemaCXX/coroutine_handle-addres-return-type.cpp b/clang/test/SemaCXX/coroutine_handle-address-return-type-exp-namespace.cpp
rename from clang/test/SemaCXX/coroutine_handle-addres-return-type.cpp
rename to clang/test/SemaCXX/coroutine_handle-address-return-type-exp-namespace.cpp
diff --git a/clang/test/SemaCXX/coroutine_handle-addres-return-type.cpp b/clang/test/SemaCXX/coroutine_handle-address-return-type.cpp
rename from clang/test/SemaCXX/coroutine_handle-addres-return-type.cpp
rename to clang/test/SemaCXX/coroutine_handle-address-return-type.cpp
--- a/clang/test/SemaCXX/coroutine_handle-addres-return-type.cpp
+++ b/clang/test/SemaCXX/coroutine_handle-address-return-type.cpp
@@ -1,6 +1,6 @@
-// RUN: %clang_cc1 -verify %s -stdlib=libc++ -std=c++1z -fcoroutines-ts -fsyntax-only
+// RUN: %clang_cc1 -verify %s -stdlib=libc++ -std=c++20 -fsyntax-only
 
-namespace std::experimental {
+namespace std {
 template <class Promise = void>
 struct coroutine_handle;
 
@@ -32,11 +32,11 @@
 
 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;
 };
 
@@ -50,18 +50,18 @@
   };
 };
 
-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;
 
diff --git a/clang/test/SemaCXX/coroutines.cpp b/clang/test/SemaCXX/coroutines-exp-namespace.cpp
copy from clang/test/SemaCXX/coroutines.cpp
copy to clang/test/SemaCXX/coroutines-exp-namespace.cpp
--- a/clang/test/SemaCXX/coroutines.cpp
+++ b/clang/test/SemaCXX/coroutines-exp-namespace.cpp
@@ -1,5 +1,6 @@
-// This file contains references to sections of the Coroutines TS, which can be
-// found at http://wg21.link/coroutines.
+// This file is the same as coroutines.cpp, except the components are defined in namespace std::experimental.
+// The intent of this test is to make sure the std::experimental implementation still works.
+// TODO: Remove this test once we drop support for <experimental/coroutine>.
 
 // RUN: %clang_cc1 -std=c++2b                 -fsyntax-only -verify=expected,cxx20_2b,cxx2b    %s -fcxx-exceptions -fexceptions -Wunused-result
 // RUN: %clang_cc1 -std=c++20                 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result
@@ -15,14 +16,13 @@
   // expected-error@-1 {{use of undeclared identifier 'a'}}
 }
 
-
 void no_coroutine_traits_bad_arg_return() {
   co_return a; // expected-error {{include <experimental/coroutine>}}
   // expected-error@-1 {{use of undeclared identifier 'a'}}
 }
 
 void no_coroutine_traits() {
-  co_await 4; // expected-error {{std::experimental::coroutine_traits type was not found; include <experimental/coroutine>}}
+  co_await 4; // expected-error {{std::coroutine_traits type was not found; include <coroutine> before defining a coroutine; include <experimental/coroutine> if your version of libcxx is less than 14.0}}
 }
 
 namespace std {
@@ -45,9 +45,10 @@
 
 template <class Ret, class... Args>
 struct coroutine_traits : public traits_sfinae_base<Ret> {};
-}}  // namespace std::experimental
+} // namespace experimental
+} // namespace std
 
-template<typename Promise> struct coro {};
+template <typename Promise> struct coro {};
 template <typename Promise, typename... Ps>
 struct std::experimental::coroutine_traits<coro<Promise>, Ps...> {
   using promise_type = Promise;
@@ -108,7 +109,7 @@
   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::experimental::coroutine_traits<double, int>::promise_type'}}
 }
 
 struct promise; // expected-note {{forward declaration}}
@@ -117,15 +118,17 @@
 template <typename... T>
 struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise; };
 template <typename... T>
-struct std::experimental::coroutine_traits<void, void_tag, T...>
-{ using promise_type = promise_void; };
+struct std::experimental::coroutine_traits<void, void_tag, T...> { using promise_type = promise_void; };
 
 // FIXME: This diagnostic is terrible.
 void undefined_promise() { // expected-error {{this function cannot be a coroutine: 'experimental::coroutine_traits<void>::promise_type' (aka 'promise') is an incomplete type}}
   co_await a;
 }
 
-struct yielded_thing { const char *p; short a, b; };
+struct yielded_thing {
+  const char *p;
+  short a, b;
+};
 
 struct not_awaitable {};
 
@@ -133,10 +136,10 @@
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
-  awaitable yield_value(int); // expected-note 2{{candidate}}
+  awaitable yield_value(int);           // expected-note 2{{candidate}}
   awaitable yield_value(yielded_thing); // expected-note 2{{candidate}}
-  not_awaitable yield_value(void()); // expected-note 2{{candidate}}
-  void return_value(int); // expected-note 2{{here}}
+  not_awaitable yield_value(void());    // expected-note 2{{candidate}}
+  void return_value(int);               // expected-note 2{{here}}
   void unhandled_exception();
 };
 
@@ -148,7 +151,7 @@
   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; include <experimental/coroutine> if your version of libcxx is less than 14.0}}
   //expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
   co_return 5; //expected-note {{function is a coroutine due to use of 'co_return' here}}
 }
@@ -165,12 +168,13 @@
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
   static coroutine_handle from_address(void *) noexcept;
 };
-}} // namespace std::experimental
+} // namespace experimental
+} // namespace std
 
 void yield() {
   co_yield 0;
   co_yield {"foo", 1, 2};
-  co_yield {1e100}; // expected-error {{cannot be narrowed}} expected-note {{explicit cast}} expected-warning {{implicit conversion}} expected-warning {{braces around scalar}}
+  co_yield {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}}
@@ -201,7 +205,7 @@
 
 void mixed_yield() {
   co_yield 0; // expected-note {{use of 'co_yield'}}
-  return; // expected-error {{not allowed in coroutine}}
+  return;     // expected-error {{not allowed in coroutine}}
 }
 
 void mixed_yield_invalid() {
@@ -233,7 +237,7 @@
 
 void mixed_await() {
   co_await a; // expected-note {{use of 'co_await'}}
-  return; // expected-error {{not allowed in coroutine}}
+  return;     // expected-error {{not allowed in coroutine}}
 }
 
 void mixed_await_invalid() {
@@ -271,7 +275,7 @@
 void mixed_coreturn_invalid(bool b) {
   if (b)
     co_return; // expected-note {{use of 'co_return'}}
-    // expected-error@-1 {{no member named 'return_void' in 'promise'}}
+  // expected-error@-1 {{no member named 'return_void' in 'promise'}}
   else
     return; // expected-error {{not allowed in coroutine}}
 }
@@ -280,7 +284,7 @@
 void mixed_coreturn_template(void_tag, bool b, T v) {
   if (b)
     co_return v; // expected-note {{use of 'co_return'}}
-    // expected-error@-1 {{no member named 'return_value' in 'promise_void'}}
+  // expected-error@-1 {{no member named 'return_value' in 'promise_void'}}
   else
     return; // expected-error {{not allowed in coroutine}}
 }
@@ -290,7 +294,7 @@
 void mixed_coreturn_template2(bool b, T) {
   if (b)
     co_return v; // expected-note {{use of 'co_return'}}
-    // expected-error@-1 {{use of undeclared identifier 'v'}}
+  // expected-error@-1 {{use of undeclared identifier 'v'}}
   else
     return; // expected-error {{not allowed in coroutine}}
 }
@@ -306,7 +310,7 @@
   ~CtorDtor() {
     co_return 0; // expected-error {{'co_return' cannot be used in a destructor}}
   }
-  void operator=(CtorDtor&) {
+  void operator=(CtorDtor &) {
     co_yield 0; // OK.
   }
   void operator=(CtorDtor const &) {
@@ -323,25 +327,27 @@
   }
 };
 
-namespace std { class type_info; }
+namespace std {
+class type_info;
+}
 
 void unevaluated() {
   decltype(co_await a); // expected-error {{'co_await' cannot be used in an unevaluated context}}
                         // expected-warning@-1 {{declaration does not declare anything}}
-  sizeof(co_await a); // expected-error {{'co_await' cannot be used in an unevaluated context}}
-                      // expected-error@-1 {{invalid application of 'sizeof' to an incomplete type 'void'}}
-                      // expected-warning@-2 {{expression with side effects has no effect in an unevaluated context}}
-  typeid(co_await a); // expected-error {{'co_await' cannot be used in an unevaluated context}}
-                      // expected-warning@-1 {{expression with side effects has no effect in an unevaluated context}}
-                      // expected-warning@-2 {{expression result unused}}
+  sizeof(co_await a);   // expected-error {{'co_await' cannot be used in an unevaluated context}}
+                        // expected-error@-1 {{invalid application of 'sizeof' to an incomplete type 'void'}}
+                        // expected-warning@-2 {{expression with side effects has no effect in an unevaluated context}}
+  typeid(co_await a);   // expected-error {{'co_await' cannot be used in an unevaluated context}}
+                        // expected-warning@-1 {{expression with side effects has no effect in an unevaluated context}}
+                        // expected-warning@-2 {{expression result unused}}
   decltype(co_yield 1); // expected-error {{'co_yield' cannot be used in an unevaluated context}}
                         // expected-warning@-1 {{declaration does not declare anything}}
-  sizeof(co_yield 2); // expected-error {{'co_yield' cannot be used in an unevaluated context}}
-                      // expected-error@-1 {{invalid application of 'sizeof' to an incomplete type 'void'}}
-                      // expected-warning@-2 {{expression with side effects has no effect in an unevaluated context}}
-  typeid(co_yield 3); // expected-error {{'co_yield' cannot be used in an unevaluated context}}
-                      // expected-warning@-1 {{expression with side effects has no effect in an unevaluated context}}
-                      // expected-warning@-2 {{expression result unused}}
+  sizeof(co_yield 2);   // expected-error {{'co_yield' cannot be used in an unevaluated context}}
+                        // expected-error@-1 {{invalid application of 'sizeof' to an incomplete type 'void'}}
+                        // expected-warning@-2 {{expression with side effects has no effect in an unevaluated context}}
+  typeid(co_yield 3);   // expected-error {{'co_yield' cannot be used in an unevaluated context}}
+                        // expected-warning@-1 {{expression with side effects has no effect in an unevaluated context}}
+                        // expected-warning@-2 {{expression result unused}}
 }
 
 // [expr.await]p2: "An await-expression shall not appear in a default argument."
@@ -351,9 +357,9 @@
 
 void await_in_catch_coroutine() {
   try {
-  } catch (...) { // FIXME: Emit a note diagnostic pointing out the try handler on this line.
+  } catch (...) {                   // FIXME: Emit a note diagnostic pointing out the try handler on this line.
     []() -> void { co_await a; }(); // OK
-    co_await a; // expected-error {{'co_await' cannot be used in the handler of a try block}}
+    co_await a;                     // expected-error {{'co_await' cannot be used in the handler of a try block}}
   }
 }
 
@@ -361,7 +367,7 @@
   try {
   } catch (...) { // FIXME: Emit a note diagnostic pointing out the try handler on this line.
     try {
-      co_await a; // expected-error {{'co_await' cannot be used in the handler of a try block}}
+      co_await a;                     // expected-error {{'co_await' cannot be used in the handler of a try block}}
       []() -> void { co_await a; }(); // OK
     } catch (...) {
       co_return 123;
@@ -410,122 +416,124 @@
 namespace adl_ns {
 struct coawait_arg_type {};
 awaitable operator co_await(coawait_arg_type) noexcept;
-}
+} // namespace adl_ns
 
 namespace dependent_operator_co_await_lookup {
-  template<typename T> void await_template(T t) {
-    // no unqualified lookup results
-    co_await t; // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::not_awaitable'}}
-    // expected-error@-1 {{call to function 'operator co_await' that is neither visible in the template definition nor found by argument-dependent lookup}}
-  };
-  template void await_template(awaitable);
+template <typename T> void await_template(T t) {
+  // no unqualified lookup results
+  co_await t; // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::not_awaitable'}}
+  // expected-error@-1 {{call to function 'operator co_await' that is neither visible in the template definition nor found by argument-dependent lookup}}
+};
+template void await_template(awaitable);
 
-  struct indirectly_awaitable { indirectly_awaitable(outer); };
-  awaitable operator co_await(indirectly_awaitable); // expected-note {{should be declared prior to}}
-  template void await_template(indirectly_awaitable);
+struct indirectly_awaitable {
+  indirectly_awaitable(outer);
+};
+awaitable operator co_await(indirectly_awaitable); // expected-note {{should be declared prior to}}
+template void await_template(indirectly_awaitable);
 
-  struct not_awaitable {};
-  template void await_template(not_awaitable); // expected-note {{instantiation}}
+struct not_awaitable {};
+template void await_template(not_awaitable); // expected-note {{instantiation}}
 
-  template<typename T> void await_template_2(T t) {
-    // one unqualified lookup result
-    co_await t;
-  };
-  template void await_template(outer); // expected-note {{instantiation}}
-  template void await_template_2(outer);
-
-  struct transform_awaitable {};
-  struct transformed {};
-
-  struct transform_promise {
-    typedef transform_awaitable await_arg;
-    coro<transform_promise> get_return_object();
-    transformed initial_suspend();
-    ::adl_ns::coawait_arg_type final_suspend() noexcept;
-    transformed await_transform(transform_awaitable);
-    void unhandled_exception();
-    void return_void();
-  };
-  template <class AwaitArg>
-  struct basic_promise {
-    typedef AwaitArg await_arg;
-    coro<basic_promise> get_return_object();
-    awaitable initial_suspend();
-    awaitable final_suspend() noexcept;
-    void unhandled_exception();
-    void return_void();
-  };
+template <typename T> void await_template_2(T t) {
+  // one unqualified lookup result
+  co_await t;
+};
+template void await_template(outer); // expected-note {{instantiation}}
+template void await_template_2(outer);
+
+struct transform_awaitable {};
+struct transformed {};
+
+struct transform_promise {
+  typedef transform_awaitable await_arg;
+  coro<transform_promise> get_return_object();
+  transformed initial_suspend();
+  ::adl_ns::coawait_arg_type final_suspend() noexcept;
+  transformed await_transform(transform_awaitable);
+  void unhandled_exception();
+  void return_void();
+};
+template <class AwaitArg>
+struct basic_promise {
+  typedef AwaitArg await_arg;
+  coro<basic_promise> get_return_object();
+  awaitable initial_suspend();
+  awaitable final_suspend() noexcept;
+  void unhandled_exception();
+  void return_void();
+};
+
+awaitable operator co_await(await_arg_1);
 
-  awaitable operator co_await(await_arg_1);
+template <typename T, typename U>
+coro<T> await_template_3(U t) {
+  co_await t;
+}
+
+template coro<basic_promise<await_arg_1>> await_template_3<basic_promise<await_arg_1>>(await_arg_1);
 
-  template <typename T, typename U>
-  coro<T> await_template_3(U t) {
+template <class T, int I = 0>
+struct dependent_member {
+  coro<T> mem_fn() const {
+    co_await typename T::await_arg{}; // expected-error {{call to function 'operator co_await'}}}
+  }
+  template <class U>
+  coro<T> dep_mem_fn(U t) {
     co_await t;
   }
+};
 
-  template coro<basic_promise<await_arg_1>> await_template_3<basic_promise<await_arg_1>>(await_arg_1);
-
-  template <class T, int I = 0>
-  struct dependent_member {
-    coro<T> mem_fn() const {
-      co_await typename T::await_arg{}; // expected-error {{call to function 'operator co_await'}}}
-    }
-    template <class U>
-    coro<T> dep_mem_fn(U t) {
-      co_await t;
-    }
-  };
+template <>
+struct dependent_member<long> {
+  // FIXME this diagnostic is terrible
+  coro<transform_promise> mem_fn() const { // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::transformed'}}
+    // expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
+    // expected-note@+1 {{function is a coroutine due to use of 'co_await' here}}
+    co_await transform_awaitable{};
+    // expected-error@-1 {{no member named 'await_ready'}}
+  }
+  template <class R, class U>
+  coro<R> dep_mem_fn(U u) { co_await u; }
+};
 
-  template <>
-  struct dependent_member<long> {
-    // FIXME this diagnostic is terrible
-    coro<transform_promise> mem_fn() const { // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::transformed'}}
-      // expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
-      // expected-note@+1 {{function is a coroutine due to use of 'co_await' here}}
-      co_await transform_awaitable{};
-      // expected-error@-1 {{no member named 'await_ready'}}
-    }
-    template <class R, class U>
-    coro<R> dep_mem_fn(U u) { co_await u; }
-  };
+awaitable operator co_await(await_arg_2); // expected-note {{'operator co_await' should be declared prior to the call site}}
 
-  awaitable operator co_await(await_arg_2); // expected-note {{'operator co_await' should be declared prior to the call site}}
+template struct dependent_member<basic_promise<await_arg_1>, 0>;
+template struct dependent_member<basic_promise<await_arg_2>, 0>; // expected-note {{in instantiation}}
 
-  template struct dependent_member<basic_promise<await_arg_1>, 0>;
-  template struct dependent_member<basic_promise<await_arg_2>, 0>; // expected-note {{in instantiation}}
+template <>
+coro<transform_promise>
+// FIXME this diagnostic is terrible
+dependent_member<long>::dep_mem_fn<transform_promise>(int) { // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::transformed'}}
+  //expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
+  //expected-note@+1 {{function is a coroutine due to use of 'co_await' here}}
+  co_await transform_awaitable{};
+  // expected-error@-1 {{no member named 'await_ready'}}
+}
 
-  template <>
-  coro<transform_promise>
-      // FIXME this diagnostic is terrible
-      dependent_member<long>::dep_mem_fn<transform_promise>(int) { // expected-error {{no member named 'await_ready' in 'dependent_operator_co_await_lookup::transformed'}}
-    //expected-note@-1 {{call to 'initial_suspend' implicitly required by the initial suspend point}}
-    //expected-note@+1 {{function is a coroutine due to use of 'co_await' here}}
-    co_await transform_awaitable{};
-    // expected-error@-1 {{no member named 'await_ready'}}
-  }
+void operator co_await(transform_awaitable) = delete;
+awaitable operator co_await(transformed);
 
-  void operator co_await(transform_awaitable) = delete;
-  awaitable operator co_await(transformed);
+template coro<transform_promise>
+    dependent_member<long>::dep_mem_fn<transform_promise>(transform_awaitable);
 
-  template coro<transform_promise>
-      dependent_member<long>::dep_mem_fn<transform_promise>(transform_awaitable);
+template <>
+coro<transform_promise> dependent_member<long>::dep_mem_fn<transform_promise>(long) {
+  co_await transform_awaitable{};
+}
 
-  template <>
-  coro<transform_promise> dependent_member<long>::dep_mem_fn<transform_promise>(long) {
+template <>
+struct dependent_member<int> {
+  coro<transform_promise> mem_fn() const {
     co_await transform_awaitable{};
   }
+};
 
-  template <>
-  struct dependent_member<int> {
-    coro<transform_promise> mem_fn() const {
-      co_await transform_awaitable{};
-    }
-  };
-
-  template coro<transform_promise> await_template_3<transform_promise>(transform_awaitable);
-  template struct dependent_member<transform_promise>;
-  template coro<transform_promise> dependent_member<transform_promise>::dep_mem_fn(transform_awaitable);
-}
+template coro<transform_promise> await_template_3<transform_promise>(transform_awaitable);
+template struct dependent_member<transform_promise>;
+template coro<transform_promise> dependent_member<transform_promise>::dep_mem_fn(transform_awaitable);
+} // namespace dependent_operator_co_await_lookup
 
 struct yield_fn_tag {};
 template <>
@@ -543,30 +551,30 @@
 };
 
 namespace placeholder {
-  awaitable f(), f(int); // expected-note 4{{possible target}}
-  int g(), g(int); // expected-note 2{{candidate}}
-  void x() {
-    co_await f; // expected-error {{reference to overloaded function}}
-  }
-  void y() {
-    co_yield g; // expected-error {{no matching member function for call to 'yield_value'}}
-  }
-  void z() {
-    co_await a;
-    co_return g; // expected-error {{address of overloaded function 'g' does not match required type 'int'}}
-  }
+awaitable f(), f(int); // expected-note 4{{possible target}}
+int g(), g(int);       // expected-note 2{{candidate}}
+void x() {
+  co_await f; // expected-error {{reference to overloaded function}}
+}
+void y() {
+  co_yield g; // expected-error {{no matching member function for call to 'yield_value'}}
+}
+void z() {
+  co_await a;
+  co_return g; // expected-error {{address of overloaded function 'g' does not match required type 'int'}}
+}
 
-  void x(yield_fn_tag) {
-    co_await f; // expected-error {{reference to overloaded function}}
-  }
-  void y(yield_fn_tag) {
-    co_yield g;
-  }
-  void z(yield_fn_tag) {
-    co_await a;
-    co_return g;
-  }
+void x(yield_fn_tag) {
+  co_await f; // expected-error {{reference to overloaded function}}
+}
+void y(yield_fn_tag) {
+  co_yield g;
+}
+void z(yield_fn_tag) {
+  co_await a;
+  co_return g;
 }
+} // namespace placeholder
 
 struct bad_promise_1 {
   suspend_always initial_suspend();
@@ -731,14 +739,14 @@
   co_await 42;
 }
 
-template<typename T> void ok_generic_lambda_coawait_PR41909() {
-  [](auto& arg) -> coro<good_promise_1> { // expected-warning {{expression result unused}}
+template <typename T> void ok_generic_lambda_coawait_PR41909() {
+  [](auto &arg) -> coro<good_promise_1> { // expected-warning {{expression result unused}}
     co_await 12;
   };
   [](auto &arg) -> coro<good_promise_1> {
     co_await 24;
   }("argument");
-  [](auto &arg) ->coro<good_promise_1> { // expected-warning {{expression result unused}}
+  [](auto &arg) -> coro<good_promise_1> { // expected-warning {{expression result unused}}
     []() -> coro<good_promise_1> {
       co_await 36;
     };
@@ -747,10 +755,9 @@
 }
 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::experimental::coroutine_traits<int, int, const char **> { using promise_type = promise; };
 
-int main(int, const char**) {
+int main(int, const char **) {
   co_await a; // expected-error {{'co_await' cannot be used in the 'main' function}}
 }
 
@@ -761,31 +768,28 @@
   void return_void();
   void unhandled_exception();
 };
-template<> struct std::experimental::coroutine_handle<good_promise_2> {};
+template <> struct std::experimental::coroutine_handle<good_promise_2> {};
 
-template<> struct std::experimental::coroutine_traits<float>
-{ using promise_type = good_promise_2; };
+template <> struct std::experimental::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 must have 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 = {};
-}
+struct nothrow_t {};
+constexpr nothrow_t nothrow = {};
+} // namespace std
 
 using SizeT = decltype(sizeof(int));
 
-void* operator new(SizeT __sz, const std::nothrow_t&) noexcept;
-void  operator delete(void* __p, const std::nothrow_t&) noexcept;
-
-
+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<>
+template <>
 struct std::experimental::coroutine_traits<int, promise_on_alloc_failure_tag> {
   struct promise_type {
     int get_return_object() {}
@@ -832,7 +836,7 @@
   void return_void();
   static coro<bad_promise_12> get_return_object_on_allocation_failure();
 
-  static void* operator new(SizeT);
+  static void *operator new(SizeT);
   // expected-error@-1 2 {{'operator new' is required to have a non-throwing noexcept specification when the promise type declares 'get_return_object_on_allocation_failure()'}}
 };
 coro<bad_promise_12> throwing_in_class_new() { // expected-note {{call to 'operator new' implicitly required by coroutine function here}}
@@ -841,11 +845,10 @@
 
 template <class T>
 coro<T> dependent_throwing_in_class_new(T) { // expected-note {{call to 'operator new' implicitly required by coroutine function here}}
-   co_return;
+  co_return;
 }
 template coro<bad_promise_12> dependent_throwing_in_class_new(bad_promise_12); // expected-note {{requested here}}
 
-
 struct good_promise_13 {
   coro<good_promise_13> get_return_object();
   suspend_always initial_suspend();
@@ -860,7 +863,7 @@
 
 template <class T>
 coro<T> dependent_uses_nothrow_new(T) {
-   co_return;
+  co_return;
 }
 template coro<good_promise_13> dependent_uses_nothrow_new(good_promise_13);
 
@@ -905,7 +908,7 @@
 }
 
 struct mismatch_gro_type_tag1 {};
-template<>
+template <>
 struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag1> {
   struct promise_type {
     void get_return_object() {} //expected-note {{member 'get_return_object' declared here}}
@@ -922,7 +925,7 @@
 }
 
 struct mismatch_gro_type_tag2 {};
-template<>
+template <>
 struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag2> {
   struct promise_type {
     void *get_return_object() {} //expected-note {{member 'get_return_object' declared here}}
@@ -940,7 +943,7 @@
 }
 
 struct mismatch_gro_type_tag3 {};
-template<>
+template <>
 struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag3> {
   struct promise_type {
     int get_return_object() {}
@@ -957,9 +960,8 @@
   co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
 }
 
-
 struct mismatch_gro_type_tag4 {};
-template<>
+template <>
 struct std::experimental::coroutine_traits<int, mismatch_gro_type_tag4> {
   struct promise_type {
     int get_return_object() {}
@@ -1038,16 +1040,16 @@
     await_suspend_type_test<bool &> b;
     await_suspend_type_test<const void> c;
     await_suspend_type_test<const volatile bool> d; // cxx20_2b-note {{in instantiation of template class}}
-    co_await a; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
-    co_await b; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
-    co_await c; // OK
-    co_await d; // OK
+    co_await a;                                     // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
+    co_await b;                                     // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
+    co_await c;                                     // OK
+    co_await d;                                     // OK
   }
 }
 
 template <int ID = 0>
 struct NoCopy {
-  NoCopy(NoCopy const&) = delete; // expected-note 2 {{deleted here}}
+  NoCopy(NoCopy const &) = delete; // expected-note 2 {{deleted here}}
 };
 template <class T, class U>
 void test_dependent_param(T t, U) {
@@ -1212,7 +1214,7 @@
   CoroMemberTag test_sanity(int *) const {
     auto TC = co_yield 0;
     static_assert(TC.template MatchesArgs<const DepTestType &>, ""); // expected-error {{static_assert failed}}
-    static_assert(TC.template MatchesArgs<>, ""); // expected-error {{static_assert failed}}
+    static_assert(TC.template MatchesArgs<>, "");                    // expected-error {{static_assert failed}}
     static_assert(TC.template MatchesArgs<const DepTestType &, int *>, "");
   }
 
@@ -1338,7 +1340,7 @@
 struct some_class;
 
 struct good_promise_custom_constructor {
-  good_promise_custom_constructor(some_class&, float, int);
+  good_promise_custom_constructor(some_class &, float, int);
   good_promise_custom_constructor(double, float, int);
   good_promise_custom_constructor() = delete;
   coro<good_promise_custom_constructor> get_return_object();
@@ -1358,8 +1360,7 @@
   good_coroutine_calls_custom_constructor(float, int) {
     co_return;
   }
-  coro<good_promise_custom_constructor>
-  static good_coroutine_calls_custom_constructor(double, float, int) {
+  coro<good_promise_custom_constructor> static good_coroutine_calls_custom_constructor(double, float, int) {
     co_return;
   }
 };
@@ -1382,11 +1383,11 @@
 }
 
 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;
-}
+  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
@@ -1399,7 +1400,6 @@
   int await_resume() noexcept { return 1; }
 };
 
-
 class awaitable_unused_warn {
 public:
   using handle_type = std::experimental::coroutine_handle<>;
@@ -1418,7 +1418,6 @@
   void unhandled_exception();
 };
 
-
 coro<check_warning_promise<awaitable_no_unused_warn>>
 test_no_unused_warning() {
   co_await awaitable_no_unused_warn();
@@ -1428,7 +1427,7 @@
 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}}
+  co_yield 42;                      // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 }
 
 struct missing_await_ready {
@@ -1445,7 +1444,7 @@
 };
 
 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_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'}}
+  co_await missing_await_resume{};  // expected-error {{no member named 'await_resume' in 'missing_await_resume'}}
 }
diff --git a/clang/test/SemaCXX/coroutines.cpp b/clang/test/SemaCXX/coroutines.cpp
--- a/clang/test/SemaCXX/coroutines.cpp
+++ b/clang/test/SemaCXX/coroutines.cpp
@@ -1,32 +1,30 @@
 // 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
+// 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
 
 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 {
@@ -45,11 +43,11 @@
 
 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;
 };
 
@@ -81,47 +79,46 @@
 };
 
 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;
 }
 
@@ -148,13 +145,12 @@
   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;
@@ -165,7 +161,7 @@
   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
   static coroutine_handle from_address(void *) noexcept;
 };
-}} // namespace std::experimental
+} // namespace std
 
 void yield() {
   co_yield 0;
@@ -529,7 +525,7 @@
 
 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());
@@ -747,8 +743,7 @@
 }
 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}}
@@ -761,12 +756,11 @@
   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 must have 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}}
 }
@@ -785,8 +779,8 @@
 
 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 {}; }
@@ -905,8 +899,8 @@
 }
 
 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 {}; }
@@ -922,8 +916,8 @@
 }
 
 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 {}; }
@@ -940,8 +934,8 @@
 }
 
 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}}
@@ -959,8 +953,8 @@
 
 
 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}}
@@ -992,13 +986,13 @@
 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 {
@@ -1006,7 +1000,7 @@
     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>
@@ -1014,7 +1008,7 @@
   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();
 };
@@ -1074,7 +1068,7 @@
 
   template <class... Args>
   static constexpr bool MatchesArgs = IsSameV<T,
-                                              std::experimental::coroutine_traits<CoroMemberTag, Args...>>;
+                                              std::coroutine_traits<CoroMemberTag, Args...>>;
 };
 
 template <class T>
@@ -1086,7 +1080,7 @@
 
 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>;
 
@@ -1103,7 +1097,7 @@
 } // 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...>;
 };
 
@@ -1189,16 +1183,16 @@
   }
 
   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;
   }
 };
@@ -1310,7 +1304,7 @@
 
 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;
 }
 
@@ -1377,7 +1371,7 @@
 
 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;
 }
 
@@ -1393,7 +1387,7 @@
 
 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; }
@@ -1402,7 +1396,7 @@
 
 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; }
@@ -1432,7 +1426,7 @@
 }
 
 struct missing_await_ready {
-  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_suspend(std::coroutine_handle<>);
   void await_resume();
 };
 struct missing_await_suspend {
@@ -1441,7 +1435,7 @@
 };
 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() {
diff --git a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
--- a/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
+++ b/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
@@ -623,7 +623,6 @@
   FileContentMappings M;
   M.push_back(std::make_pair("/coro_header", R"cpp(
 namespace std {
-namespace experimental {
 
 template <class... Args>
 struct void_t_imp {
@@ -642,7 +641,7 @@
 
 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>
@@ -658,14 +657,13 @@
   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>