{

friend struct final_awaitable;

struct final_awaitable

{

bool await_ready() const noexcept { return false; }

#if CPPCORO_COMPILER_SUPPORTS_SYMMETRIC_TRANSFER

template<typename PROMISE>

std::experimental::coroutine_handle<> await_suspend(

std::experimental::coroutine_handle<PROMISE> coro) noexcept

{

return coro.promise().m_continuation;

}

#else

// HACK: Need to add CPPCORO_NOINLINE to await_suspend() method

// to avoid MSVC 2017.8 from spilling some local variables in

// await_suspend() onto the coroutine frame in some cases.

// Without this, some tests in async_auto_reset_event_tests.cpp

// were crashing under x86 optimised builds.

template<typename PROMISE>

CPPCORO_NOINLINE

void await_suspend(std::experimental::coroutine_handle<PROMISE> coroutine)

{

task_promise_base& promise = coroutine.promise();

// Use 'release' memory semantics in case we finish before the

// awaiter can suspend so that the awaiting thread sees our

// writes to the resulting value.

// Use 'acquire' memory semantics in case the caller registered

// the continuation before we finished. Ensure we see their write

// to m_continuation.

if (promise.m_state.exchange(true, std::memory_order_acq_rel))

{

promise.m_continuation.resume();

}

}

#endif

void await_resume() noexcept {}

};

public:

task_promise_base() noexcept

#if !CPPCORO_COMPILER_SUPPORTS_SYMMETRIC_TRANSFER

: m_state(false)

#endif

{}

auto initial_suspend() noexcept

{

return std::experimental::suspend_always{};

}

auto final_suspend() noexcept

{

return final_awaitable{};

}

#if CPPCORO_COMPILER_SUPPORTS_SYMMETRIC_TRANSFER

void set_continuation(std::experimental::coroutine_handle<> continuation) noexcept

{

m_continuation = continuation;

}

#else

bool try_set_continuation(std::experimental::coroutine_handle<> continuation)

{

m_continuation = continuation;

return !m_state.exchange(true, std::memory_order_acq_rel);

}

#endif

private:

std::experimental::coroutine_handle<> m_continuation;

#if !CPPCORO_COMPILER_SUPPORTS_SYMMETRIC_TRANSFER

// Initially false. Set to true when either a continuation is registered

// or when the coroutine has run to completion. Whichever operation

// successfully transitions from false->true got there first.

std::atomic<bool> m_state;

#endif

};

template<typename T>

class task_promise final : public task_promise_base

{

public:

task_promise() noexcept {}

~task_promise()

{

switch (m_resultType)

{

case result_type::value:

m_value.~T();

break;

case result_type::exception:

m_exception.~exception_ptr();

break;

default:

break;

}

}

task<T> get_return_object() noexcept;

void unhandled_exception() noexcept

{

::new (static_cast<void*>(std::addressof(m_exception))) std::exception_ptr(

std::current_exception());

m_resultType = result_type::exception;

}

template<

typename VALUE,

typename = std::enable_if_t<std::is_convertible_v<VALUE&&, T>>>

void return_value(VALUE&& value)

noexcept(std::is_nothrow_constructible_v<T, VALUE&&>)

{

::new (static_cast<void*>(std::addressof(m_value))) T(std::forward<VALUE>(value));

m_resultType = result_type::value;

}

T& result() &

{

if (m_resultType == result_type::exception)

{

std::rethrow_exception(m_exception);

}

assert(m_resultType == result_type::value);

return m_value;

}

// HACK: Need to have co_await of task<int> return prvalue rather than

// rvalue-reference to work around an issue with MSVC where returning

// rvalue reference of a fundamental type from await_resume() will

// cause the value to be copied to a temporary. This breaks the

// sync_wait() implementation.

// See https://github.com/lewissbaker/cppcoro/issues/40#issuecomment-326864107

using rvalue_type = std::conditional_t<

std::is_arithmetic_v<T> || std::is_pointer_v<T>,

T,

T&&>;

rvalue_type result() &&

{

if (m_resultType == result_type::exception)

{

std::rethrow_exception(m_exception);

}

assert(m_resultType == result_type::value);

return std::move(m_value);

}

private:

enum class result_type { empty, value, exception };

result_type m_resultType = result_type::empty;

union

{

T m_value;

std::exception_ptr m_exception;

};

};

template<>

class task_promise<void> : public task_promise_base

{

public:

task_promise() noexcept = default;

task<void> get_return_object() noexcept;

void return_void() noexcept

{}

void unhandled_exception() noexcept

{

m_exception = std::current_exception();

}

void result()

{

if (m_exception)

{

std::rethrow_exception(m_exception);

}

}

private:

std::exception_ptr m_exception;

};

template<typename T>

class task_promise<T&> : public task_promise_base

{

public:

task_promise() noexcept = default;

task<T&> get_return_object() noexcept;

void unhandled_exception() noexcept

{

m_exception = std::current_exception();

}

void return_value(T& value) noexcept

{

m_value = std::addressof(value);

}

T& result()

{

if (m_exception)

{

std::rethrow_exception(m_exception);

}

return *m_value;

}

private:

T* m_value = nullptr;

std::exception_ptr m_exception;

};

{

std::experimental::coroutine_handle<promise_type> m_coroutine;

awaitable_base(std::experimental::coroutine_handle<promise_type> coroutine) noexcept

: m_coroutine(coroutine)

{}

bool await_ready() const noexcept

{

return !m_coroutine || m_coroutine.done();

}

#if CPPCORO_COMPILER_SUPPORTS_SYMMETRIC_TRANSFER

std::experimental::coroutine_handle<> await_suspend(

std::experimental::coroutine_handle<> awaitingCoroutine) noexcept

{

m_coroutine.promise().set_continuation(awaitingCoroutine);

return m_coroutine;

}

#else

bool await_suspend(std::experimental::coroutine_handle<> awaitingCoroutine) noexcept

{

// NOTE: We are using the bool-returning version of await_suspend() here

// to work around a potential stack-overflow issue if a coroutine

// awaits many synchronously-completing tasks in a loop.

//

// We first start the task by calling resume() and then conditionally

// attach the continuation if it has not already completed. This allows us

// to immediately resume the awaiting coroutine without increasing

// the stack depth, avoiding the stack-overflow problem. However, it has

// the down-side of requiring a std::atomic to arbitrate the race between

// the coroutine potentially completing on another thread concurrently

// with registering the continuation on this thread.

//

// We can eliminate the use of the std::atomic once we have access to

// coroutine_handle-returning await_suspend() on both MSVC and Clang

// as this will provide ability to suspend the awaiting coroutine and

// resume another coroutine with a guaranteed tail-call to resume().

m_coroutine.resume();

return m_coroutine.promise().try_set_continuation(awaitingCoroutine);

}

#endif

: m_coroutine(t.m_coroutine)

{

t.m_coroutine = nullptr;

{

using awaitable_base::awaitable_base;

decltype(auto) await_resume()

{

if (!this->m_coroutine)

{

throw broken_promise{};

}

return this->m_coroutine.promise().result();

}

{

using awaitable_base::awaitable_base;

decltype(auto) await_resume()

{

if (!this->m_coroutine)

{

throw broken_promise{};

}

return std::move(this->m_coroutine.promise()).result();

}

{

struct awaitable : awaitable_base

{

using awaitable_base::awaitable_base;

void await_resume() const noexcept {}

};

return awaitable{ m_coroutine };

-> task<detail::remove_rvalue_reference_t<typename awaitable_traits<AWAITABLE>::await_result_t>>

{

co_return co_await static_cast<AWAITABLE&&>(awaitable);