C++20 coroutine support (#748)

kennykerr · web-flow · commit ff7ab2531939 · 2020-09-21T11:18:24.000-07:00
diff --git a/scratch/scratch.vcxproj b/scratch/scratch.vcxproj
@@ -129,7 +129,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>$(OutputPath);Generated Files;..\..\..\library</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>NOMINMAX;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -151,7 +151,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>$(OutputPath);Generated Files;..\..\..\library</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -171,7 +171,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>$(OutputPath);Generated Files;..\..\..\library</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -191,7 +191,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>$(OutputPath);Generated Files;..\..\..\library</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -211,7 +211,7 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>$(OutputPath);Generated Files;..\..\..\library</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -233,7 +233,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>$(OutputPath);Generated Files;..\..\..\library</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>NOMINMAX;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -257,7 +257,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>$(OutputPath);Generated Files;..\..\..\library</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>NOMINMAX;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
@@ -281,7 +281,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>$(OutputPath);Generated Files;..\..\..\library</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>NOMINMAX;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
diff --git a/strings/base_coroutine_foundation.h b/strings/base_coroutine_foundation.h
@@ -100,7 +100,7 @@ namespace winrt::impl
 
     struct disconnect_aware_handler
     {
-        disconnect_aware_handler(std::experimental::coroutine_handle<> handle) noexcept
+        disconnect_aware_handler(coroutine_handle<> handle) noexcept
             : m_handle(handle) { }
 
         disconnect_aware_handler(disconnect_aware_handler&& other) noexcept
@@ -119,7 +119,7 @@ namespace winrt::impl
 
     private:
         resume_apartment_context m_context;
-        std::experimental::coroutine_handle<> m_handle;
+        coroutine_handle<> m_handle;
 
         void Complete()
         {
@@ -148,7 +148,7 @@ namespace winrt::impl
             return false;
         }
 
-        void await_suspend(std::experimental::coroutine_handle<> handle)
+        void await_suspend(coroutine_handle<> handle)
         {
             auto extend_lifetime = async;
             async.Completed([this, handler = disconnect_aware_handler{ handle }](auto&&, auto operation_status) mutable
@@ -282,7 +282,7 @@ namespace winrt::impl
             return true;
         }
 
-        void await_suspend(std::experimental::coroutine_handle<>) const noexcept
+        void await_suspend(coroutine_handle<>) const noexcept
         {
         }
 
@@ -324,7 +324,7 @@ namespace winrt::impl
             return true;
         }
 
-        void await_suspend(std::experimental::coroutine_handle<>) const noexcept
+        void await_suspend(coroutine_handle<>) const noexcept
         {
         }
 
@@ -355,7 +355,7 @@ namespace winrt::impl
             if (remaining == 0)
             {
                 std::atomic_thread_fence(std::memory_order_acquire);
-                std::experimental::coroutine_handle<Derived>::from_promise(*static_cast<Derived*>(this)).destroy();
+                coroutine_handle<Derived>::from_promise(*static_cast<Derived*>(this)).destroy();
             }
 
             return remaining;
@@ -496,7 +496,7 @@ namespace winrt::impl
             }
         }
 
-        std::experimental::suspend_never initial_suspend() const noexcept
+        suspend_never initial_suspend() const noexcept
         {
             return{};
         }
@@ -514,7 +514,7 @@ namespace winrt::impl
             {
             }
 
-            bool await_suspend(std::experimental::coroutine_handle<>) const noexcept
+            bool await_suspend(coroutine_handle<>) const noexcept
             {
                 promise->set_completed();
                 uint32_t const remaining = promise->subtract_reference();
@@ -629,7 +629,11 @@ namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace std::experimental
+#ifdef __cpp_lib_coroutine
+namespace std
+#else
+namespace std::experimental
+#endif
 {
     template <typename... Args>
     struct coroutine_traits<winrt::Windows::Foundation::IAsyncAction, Args...>
diff --git a/strings/base_coroutine_system.h b/strings/base_coroutine_system.h
@@ -23,7 +23,7 @@ WINRT_EXPORT namespace winrt
                 return m_queued;
             }
 
-            bool await_suspend(std::experimental::coroutine_handle<> handle)
+            bool await_suspend(impl::coroutine_handle<> handle)
             {
                 return m_dispatcher.TryEnqueue(m_priority, [handle, this]
                     {
diff --git a/strings/base_coroutine_system_winui.h b/strings/base_coroutine_system_winui.h
@@ -23,7 +23,7 @@ WINRT_EXPORT namespace winrt
                 return m_queued;
             }
 
-            bool await_suspend(std::experimental::coroutine_handle<> handle)
+            bool await_suspend(impl::coroutine_handle<> handle)
             {
                 return m_dispatcher.TryEnqueue(m_priority, [handle, this]
                     {
diff --git a/strings/base_coroutine_threadpool.h b/strings/base_coroutine_threadpool.h
@@ -11,10 +11,10 @@ namespace winrt::impl
 
     inline void __stdcall resume_background_callback(void*, void* context) noexcept
     {
-        std::experimental::coroutine_handle<>::from_address(context)();
+        coroutine_handle<>::from_address(context)();
     };
 
-    inline auto resume_background(std::experimental::coroutine_handle<> handle)
+    inline auto resume_background(coroutine_handle<> handle)
     {
         submit_threadpool_callback(resume_background_callback, handle.address());
     }
@@ -56,26 +56,26 @@ namespace winrt::impl
 
     inline int32_t __stdcall resume_apartment_callback(com_callback_args* args) noexcept
     {
-        std::experimental::coroutine_handle<>::from_address(args->data)();
+        coroutine_handle<>::from_address(args->data)();
         return 0;
     };
 
-    inline void resume_apartment_sync(com_ptr<IContextCallback> const& context, std::experimental::coroutine_handle<> handle)
+    inline void resume_apartment_sync(com_ptr<IContextCallback> const& context, coroutine_handle<> handle)
     {
         com_callback_args args{};
         args.data = handle.address();
 
         check_hresult(context->ContextCallback(resume_apartment_callback, &args, guid_of<ICallbackWithNoReentrancyToApplicationSTA>(), 5, nullptr));
     }
 
-    inline void resume_apartment_on_threadpool(com_ptr<IContextCallback> const& context, std::experimental::coroutine_handle<> handle)
+    inline void resume_apartment_on_threadpool(com_ptr<IContextCallback> const& context, coroutine_handle<> handle)
     {
         struct threadpool_resume
         {
-            threadpool_resume(com_ptr<IContextCallback> const& context, std::experimental::coroutine_handle<> handle) :
+            threadpool_resume(com_ptr<IContextCallback> const& context, coroutine_handle<> handle) :
                 m_context(context), m_handle(handle) { }
             com_ptr<IContextCallback> m_context;
-            std::experimental::coroutine_handle<> m_handle;
+            coroutine_handle<> m_handle;
         };
         auto state = std::make_unique<threadpool_resume>(context, handle);
         submit_threadpool_callback([](void*, void* p)
@@ -86,7 +86,7 @@ namespace winrt::impl
         state.release();
     }
 
-    inline auto resume_apartment(resume_apartment_context const& context, std::experimental::coroutine_handle<> handle)
+    inline auto resume_apartment(resume_apartment_context const& context, coroutine_handle<> handle)
     {
         if ((context.m_context == nullptr) || (context.m_context == try_capture<IContextCallback>(WINRT_IMPL_CoGetObjectContext)))
         {
@@ -246,7 +246,7 @@ namespace winrt::impl
         }
 
         template <typename U>
-        auto await_suspend(std::experimental::coroutine_handle<U> handle)
+        auto await_suspend(coroutine_handle<U> handle)
         {
             return awaitable.await_suspend(handle);
         }
@@ -278,7 +278,7 @@ WINRT_EXPORT namespace winrt
             {
             }
 
-            void await_suspend(std::experimental::coroutine_handle<> handle) const
+            void await_suspend(impl::coroutine_handle<> handle) const
             {
                 impl::resume_background(handle);
             }
@@ -305,7 +305,7 @@ WINRT_EXPORT namespace winrt
             {
             }
 
-            void await_suspend(std::experimental::coroutine_handle<> resume)
+            void await_suspend(impl::coroutine_handle<> resume)
             {
                 m_resume = resume;
 
@@ -325,7 +325,7 @@ WINRT_EXPORT namespace winrt
             }
 
             T const& m_context;
-            std::experimental::coroutine_handle<> m_resume{ nullptr };
+            impl::coroutine_handle<> m_resume{ nullptr };
         };
 
         return awaitable{ context };
@@ -342,7 +342,7 @@ WINRT_EXPORT namespace winrt
         {
         }
 
-        void await_suspend(std::experimental::coroutine_handle<> handle) const
+        void await_suspend(impl::coroutine_handle<> handle) const
         {
             auto copy = context; // resuming may destruct *this, so use a copy
             impl::resume_apartment(copy, handle);
@@ -377,7 +377,7 @@ WINRT_EXPORT namespace winrt
                 return m_duration.count() <= 0;
             }
 
-            void await_suspend(std::experimental::coroutine_handle<> handle)
+            void await_suspend(impl::coroutine_handle<> handle)
             {
                 m_handle = handle;
                 m_timer.attach(check_pointer(WINRT_IMPL_CreateThreadpoolTimer(callback, this, nullptr)));
@@ -435,7 +435,7 @@ WINRT_EXPORT namespace winrt
 
             handle_type<timer_traits> m_timer;
             Windows::Foundation::TimeSpan m_duration;
-            std::experimental::coroutine_handle<> m_handle;
+            impl::coroutine_handle<> m_handle;
             std::atomic<state> m_state{ state::idle };
         };
 
@@ -475,7 +475,7 @@ WINRT_EXPORT namespace winrt
                 return WINRT_IMPL_WaitForSingleObject(m_handle, 0) == 0;
             }
 
-            void await_suspend(std::experimental::coroutine_handle<> resume)
+            void await_suspend(impl::coroutine_handle<> resume)
             {
                 m_resume = resume;
                 m_wait.attach(check_pointer(WINRT_IMPL_CreateThreadpoolWait(callback, this, nullptr)));
@@ -538,7 +538,7 @@ WINRT_EXPORT namespace winrt
             Windows::Foundation::TimeSpan m_timeout;
             void* m_handle;
             uint32_t m_result{};
-            std::experimental::coroutine_handle<> m_resume{ nullptr };
+            impl::coroutine_handle<> m_resume{ nullptr };
             std::atomic<state> m_state{ state::idle };
         };
 
@@ -568,7 +568,7 @@ WINRT_EXPORT namespace winrt
         {
         }
 
-        void await_suspend(std::experimental::coroutine_handle<> handle)
+        void await_suspend(impl::coroutine_handle<> handle)
         {
             if (!WINRT_IMPL_TrySubmitThreadpoolCallback(callback, handle.address(), &m_environment))
             {
@@ -580,7 +580,7 @@ WINRT_EXPORT namespace winrt
 
         static void __stdcall callback(void*, void* context) noexcept
         {
-            std::experimental::coroutine_handle<>::from_address(context)();
+            impl::coroutine_handle<>::from_address(context)();
         }
 
         struct pool_traits
@@ -628,7 +628,11 @@ WINRT_EXPORT namespace winrt
     struct fire_and_forget {};
 }
 
+#ifdef __cpp_lib_coroutine
+namespace std
+#else
 namespace std::experimental
+#endif
 {
     template <typename... Args>
     struct coroutine_traits<winrt::fire_and_forget, Args...>
diff --git a/strings/base_coroutine_ui_core.h b/strings/base_coroutine_ui_core.h
@@ -22,7 +22,7 @@ WINRT_EXPORT namespace winrt
             {
             }
 
-            void await_suspend(std::experimental::coroutine_handle<> handle) const
+            void await_suspend(impl::coroutine_handle<> handle) const
             {
                 m_dispatcher.RunAsync(m_priority, [handle]
                     {
diff --git a/strings/base_deferral.h b/strings/base_deferral.h
@@ -22,7 +22,7 @@ WINRT_EXPORT namespace winrt
 
         [[nodiscard]] Windows::Foundation::IAsyncAction wait_for_deferrals()
         {
-            struct awaitable : std::experimental::suspend_always
+            struct awaitable : impl::suspend_always
             {
                 bool await_suspend(coroutine_handle handle)
                 {
@@ -37,7 +37,7 @@ WINRT_EXPORT namespace winrt
 
     private:
 
-        using coroutine_handle = std::experimental::coroutine_handle<>;
+        using coroutine_handle = impl::coroutine_handle<>;
 
         void one_deferral_completed()
         {
diff --git a/strings/base_includes.h b/strings/base_includes.h

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ namespace winrt::impl`
`100`	`100`
`101`	`101`	`struct disconnect_aware_handler`
`102`	`102`	`{`
`103`		`- disconnect_aware_handler(std::experimental::coroutine_handle<> handle) noexcept`
	`103`	`+ disconnect_aware_handler(coroutine_handle<> handle) noexcept`
`104`	`104`	`: m_handle(handle) { }`
`105`	`105`
`106`	`106`	`disconnect_aware_handler(disconnect_aware_handler&& other) noexcept`
`@@ -119,7 +119,7 @@ namespace winrt::impl`
`119`	`119`
`120`	`120`	`private:`
`121`	`121`	`resume_apartment_context m_context;`
`122`		`- std::experimental::coroutine_handle<> m_handle;`
	`122`	`+ coroutine_handle<> m_handle;`
`123`	`123`
`124`	`124`	`void Complete()`
`125`	`125`	`{`
`@@ -148,7 +148,7 @@ namespace winrt::impl`
`148`	`148`	`return false;`
`149`	`149`	`}`
`150`	`150`
`151`		`- void await_suspend(std::experimental::coroutine_handle<> handle)`
	`151`	`+ void await_suspend(coroutine_handle<> handle)`
`152`	`152`	`{`
`153`	`153`	`auto extend_lifetime = async;`
`154`	`154`	`async.Completed([this, handler = disconnect_aware_handler{ handle }](auto&&, auto operation_status) mutable`
`@@ -282,7 +282,7 @@ namespace winrt::impl`
`282`	`282`	`return true;`
`283`	`283`	`}`
`284`	`284`
`285`		`- void await_suspend(std::experimental::coroutine_handle<>) const noexcept`
	`285`	`+ void await_suspend(coroutine_handle<>) const noexcept`
`286`	`286`	`{`
`287`	`287`	`}`
`288`	`288`
`@@ -324,7 +324,7 @@ namespace winrt::impl`
`324`	`324`	`return true;`
`325`	`325`	`}`
`326`	`326`
`327`		`- void await_suspend(std::experimental::coroutine_handle<>) const noexcept`
	`327`	`+ void await_suspend(coroutine_handle<>) const noexcept`
`328`	`328`	`{`
`329`	`329`	`}`
`330`	`330`
`@@ -355,7 +355,7 @@ namespace winrt::impl`
`355`	`355`	`if (remaining == 0)`
`356`	`356`	`{`
`357`	`357`	`std::atomic_thread_fence(std::memory_order_acquire);`
`358`		`- std::experimental::coroutine_handle<Derived>::from_promise(static_cast<Derived>(this)).destroy();`
	`358`	`+ coroutine_handle<Derived>::from_promise(static_cast<Derived>(this)).destroy();`
`359`	`359`	`}`
`360`	`360`
`361`	`361`	`return remaining;`
`@@ -496,7 +496,7 @@ namespace winrt::impl`
`496`	`496`	`}`
`497`	`497`	`}`
`498`	`498`
`499`		`- std::experimental::suspend_never initial_suspend() const noexcept`
	`499`	`+ suspend_never initial_suspend() const noexcept`
`500`	`500`	`{`
`501`	`501`	`return{};`
`502`	`502`	`}`
`@@ -514,7 +514,7 @@ namespace winrt::impl`
`514`	`514`	`{`
`515`	`515`	`}`
`516`	`516`
`517`		`- bool await_suspend(std::experimental::coroutine_handle<>) const noexcept`
	`517`	`+ bool await_suspend(coroutine_handle<>) const noexcept`
`518`	`518`	`{`
`519`	`519`	`promise->set_completed();`
`520`	`520`	`uint32_t const remaining = promise->subtract_reference();`
`@@ -629,7 +629,11 @@ namespace winrt::impl`
`629`	`629`	`};`
`630`	`630`	`}`
`631`	`631`
`632`		`-WINRT_EXPORT namespace std::experimental`
	`632`	`+#ifdef __cpp_lib_coroutine`
	`633`	`+namespace std`
	`634`	`+#else`
	`635`	`+namespace std::experimental`
	`636`	`+#endif`
`633`	`637`	`{`
`634`	`638`	`template <typename... Args>`
`635`	`639`	`struct coroutine_traits<winrt::Windows::Foundation::IAsyncAction, Args...>`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ WINRT_EXPORT namespace winrt`
`23`	`23`	`return m_queued;`
`24`	`24`	`}`
`25`	`25`
`26`		`- bool await_suspend(std::experimental::coroutine_handle<> handle)`
	`26`	`+ bool await_suspend(impl::coroutine_handle<> handle)`
`27`	`27`	`{`
`28`	`28`	`return m_dispatcher.TryEnqueue(m_priority, [handle, this]`
`29`	`29`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,10 @@ namespace winrt::impl`
`11`	`11`
`12`	`12`	`inline void __stdcall resume_background_callback(void, void context) noexcept`
`13`	`13`	`{`
`14`		`- std::experimental::coroutine_handle<>::from_address(context)();`
	`14`	`+ coroutine_handle<>::from_address(context)();`
`15`	`15`	`};`
`16`	`16`
`17`		`- inline auto resume_background(std::experimental::coroutine_handle<> handle)`
	`17`	`+ inline auto resume_background(coroutine_handle<> handle)`
`18`	`18`	`{`
`19`	`19`	`submit_threadpool_callback(resume_background_callback, handle.address());`
`20`	`20`	`}`
`@@ -56,26 +56,26 @@ namespace winrt::impl`
`56`	`56`
`57`	`57`	`inline int32_t __stdcall resume_apartment_callback(com_callback_args* args) noexcept`
`58`	`58`	`{`
`59`		`- std::experimental::coroutine_handle<>::from_address(args->data)();`
	`59`	`+ coroutine_handle<>::from_address(args->data)();`
`60`	`60`	`return 0;`
`61`	`61`	`};`
`62`	`62`
`63`		`- inline void resume_apartment_sync(com_ptr<IContextCallback> const& context, std::experimental::coroutine_handle<> handle)`
	`63`	`+ inline void resume_apartment_sync(com_ptr<IContextCallback> const& context, coroutine_handle<> handle)`
`64`	`64`	`{`
`65`	`65`	`com_callback_args args{};`
`66`	`66`	`args.data = handle.address();`
`67`	`67`
`68`	`68`	`check_hresult(context->ContextCallback(resume_apartment_callback, &args, guid_of<ICallbackWithNoReentrancyToApplicationSTA>(), 5, nullptr));`
`69`	`69`	`}`
`70`	`70`
`71`		`- inline void resume_apartment_on_threadpool(com_ptr<IContextCallback> const& context, std::experimental::coroutine_handle<> handle)`
	`71`	`+ inline void resume_apartment_on_threadpool(com_ptr<IContextCallback> const& context, coroutine_handle<> handle)`
`72`	`72`	`{`
`73`	`73`	`struct threadpool_resume`
`74`	`74`	`{`
`75`		`- threadpool_resume(com_ptr<IContextCallback> const& context, std::experimental::coroutine_handle<> handle) :`
	`75`	`+ threadpool_resume(com_ptr<IContextCallback> const& context, coroutine_handle<> handle) :`
`76`	`76`	`m_context(context), m_handle(handle) { }`
`77`	`77`	`com_ptr<IContextCallback> m_context;`
`78`		`- std::experimental::coroutine_handle<> m_handle;`
	`78`	`+ coroutine_handle<> m_handle;`
`79`	`79`	`};`
`80`	`80`	`auto state = std::make_unique<threadpool_resume>(context, handle);`
`81`	`81`	`submit_threadpool_callback([](void, void p)`
`@@ -86,7 +86,7 @@ namespace winrt::impl`
`86`	`86`	`state.release();`
`87`	`87`	`}`
`88`	`88`
`89`		`- inline auto resume_apartment(resume_apartment_context const& context, std::experimental::coroutine_handle<> handle)`
	`89`	`+ inline auto resume_apartment(resume_apartment_context const& context, coroutine_handle<> handle)`
`90`	`90`	`{`
`91`	`91`	`if ((context.m_context == nullptr) \|\| (context.m_context == try_capture<IContextCallback>(WINRT_IMPL_CoGetObjectContext)))`
`92`	`92`	`{`
`@@ -246,7 +246,7 @@ namespace winrt::impl`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`template <typename U>`
`249`		`- auto await_suspend(std::experimental::coroutine_handle<U> handle)`
	`249`	`+ auto await_suspend(coroutine_handle<U> handle)`
`250`	`250`	`{`
`251`	`251`	`return awaitable.await_suspend(handle);`
`252`	`252`	`}`
`@@ -278,7 +278,7 @@ WINRT_EXPORT namespace winrt`
`278`	`278`	`{`
`279`	`279`	`}`
`280`	`280`
`281`		`- void await_suspend(std::experimental::coroutine_handle<> handle) const`
	`281`	`+ void await_suspend(impl::coroutine_handle<> handle) const`
`282`	`282`	`{`
`283`	`283`	`impl::resume_background(handle);`
`284`	`284`	`}`
`@@ -305,7 +305,7 @@ WINRT_EXPORT namespace winrt`
`305`	`305`	`{`
`306`	`306`	`}`
`307`	`307`
`308`		`- void await_suspend(std::experimental::coroutine_handle<> resume)`
	`308`	`+ void await_suspend(impl::coroutine_handle<> resume)`
`309`	`309`	`{`
`310`	`310`	`m_resume = resume;`
`311`	`311`
`@@ -325,7 +325,7 @@ WINRT_EXPORT namespace winrt`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`T const& m_context;`
`328`		`- std::experimental::coroutine_handle<> m_resume{ nullptr };`
	`328`	`+ impl::coroutine_handle<> m_resume{ nullptr };`
`329`	`329`	`};`
`330`	`330`
`331`	`331`	`return awaitable{ context };`
`@@ -342,7 +342,7 @@ WINRT_EXPORT namespace winrt`
`342`	`342`	`{`
`343`	`343`	`}`
`344`	`344`
`345`		`- void await_suspend(std::experimental::coroutine_handle<> handle) const`
	`345`	`+ void await_suspend(impl::coroutine_handle<> handle) const`
`346`	`346`	`{`
`347`	`347`	`auto copy = context; // resuming may destruct *this, so use a copy`
`348`	`348`	`impl::resume_apartment(copy, handle);`
`@@ -377,7 +377,7 @@ WINRT_EXPORT namespace winrt`
`377`	`377`	`return m_duration.count() <= 0;`
`378`	`378`	`}`
`379`	`379`
`380`		`- void await_suspend(std::experimental::coroutine_handle<> handle)`
	`380`	`+ void await_suspend(impl::coroutine_handle<> handle)`
`381`	`381`	`{`
`382`	`382`	`m_handle = handle;`
`383`	`383`	`m_timer.attach(check_pointer(WINRT_IMPL_CreateThreadpoolTimer(callback, this, nullptr)));`
`@@ -435,7 +435,7 @@ WINRT_EXPORT namespace winrt`
`435`	`435`
`436`	`436`	`handle_type<timer_traits> m_timer;`
`437`	`437`	`Windows::Foundation::TimeSpan m_duration;`
`438`		`- std::experimental::coroutine_handle<> m_handle;`
	`438`	`+ impl::coroutine_handle<> m_handle;`
`439`	`439`	`std::atomic<state> m_state{ state::idle };`
`440`	`440`	`};`
`441`	`441`
`@@ -475,7 +475,7 @@ WINRT_EXPORT namespace winrt`
`475`	`475`	`return WINRT_IMPL_WaitForSingleObject(m_handle, 0) == 0;`
`476`	`476`	`}`
`477`	`477`
`478`		`- void await_suspend(std::experimental::coroutine_handle<> resume)`
	`478`	`+ void await_suspend(impl::coroutine_handle<> resume)`
`479`	`479`	`{`
`480`	`480`	`m_resume = resume;`
`481`	`481`	`m_wait.attach(check_pointer(WINRT_IMPL_CreateThreadpoolWait(callback, this, nullptr)));`
`@@ -538,7 +538,7 @@ WINRT_EXPORT namespace winrt`
`538`	`538`	`Windows::Foundation::TimeSpan m_timeout;`
`539`	`539`	`void* m_handle;`
`540`	`540`	`uint32_t m_result{};`
`541`		`- std::experimental::coroutine_handle<> m_resume{ nullptr };`
	`541`	`+ impl::coroutine_handle<> m_resume{ nullptr };`
`542`	`542`	`std::atomic<state> m_state{ state::idle };`
`543`	`543`	`};`
`544`	`544`
`@@ -568,7 +568,7 @@ WINRT_EXPORT namespace winrt`
`568`	`568`	`{`
`569`	`569`	`}`
`570`	`570`
`571`		`- void await_suspend(std::experimental::coroutine_handle<> handle)`
	`571`	`+ void await_suspend(impl::coroutine_handle<> handle)`
`572`	`572`	`{`
`573`	`573`	`if (!WINRT_IMPL_TrySubmitThreadpoolCallback(callback, handle.address(), &m_environment))`
`574`	`574`	`{`
`@@ -580,7 +580,7 @@ WINRT_EXPORT namespace winrt`
`580`	`580`
`581`	`581`	`static void __stdcall callback(void, void context) noexcept`
`582`	`582`	`{`
`583`		`- std::experimental::coroutine_handle<>::from_address(context)();`
	`583`	`+ impl::coroutine_handle<>::from_address(context)();`
`584`	`584`	`}`
`585`	`585`
`586`	`586`	`struct pool_traits`
`@@ -628,7 +628,11 @@ WINRT_EXPORT namespace winrt`
`628`	`628`	`struct fire_and_forget {};`
`629`	`629`	`}`
`630`	`630`
	`631`	`+#ifdef __cpp_lib_coroutine`
	`632`	`+namespace std`
	`633`	`+#else`
`631`	`634`	`namespace std::experimental`
	`635`	`+#endif`
`632`	`636`	`{`
`633`	`637`	`template <typename... Args>`
`634`	`638`	`struct coroutine_traits<winrt::fire_and_forget, Args...>`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ WINRT_EXPORT namespace winrt`
`22`	`22`	`{`
`23`	`23`	`}`
`24`	`24`
`25`		`- void await_suspend(std::experimental::coroutine_handle<> handle) const`
	`25`	`+ void await_suspend(impl::coroutine_handle<> handle) const`
`26`	`26`	`{`
`27`	`27`	`m_dispatcher.RunAsync(m_priority, [handle]`
`28`	`28`	`{`