#include <iostream>
#include <coroutine>

class eager {
public:
    struct promise_type {
        promise_type() { std::cout << "promise_type ctor" << std::endl; }
        ~promise_type() { std::cout << "~promise_type dtor" << std::endl; }
        struct return_object {
            return_object() { std::cout << "return_object ctor" << std::endl; }
            ~return_object() { std::cout << "~return_object dtor" << std::endl; }
            operator eager() { return {}; }
        };
        auto get_return_object() noexcept { return return_object{}; }
        constexpr auto initial_suspend() const noexcept { return std::suspend_never{}; }
        constexpr auto final_suspend() const noexcept { return std::suspend_never{}; }
        constexpr auto return_void() const noexcept {}
        auto unhandled_exception() -> void { throw; }
    };
};

auto coroutine() -> eager {
    co_return;
}

auto main() -> int
{
    coroutine();
    return 0;
}

您可以在这里看到MSVC、clang和GCC的结果：https://godbolt.org/z/Yan9s9TPE
根据大量关于协程的文章，将coroutine()转换为...

auto coroutine() -> eager {
    eager::promise_type promise;
    auto res = promise.get_return_object();
    // initial suspend
    promise.return_void();
    // final suspend
    return res;
}

乍一看，由于promise对象是先构造的，我以为它会是最后一个被析构的对象。
但是，MSVC和GCC显示相反的顺序：

// from MSVC/GCC
promise_type ctor
return_object ctor
~promise_type dtor
~return_object dtor

另一方面，clang显示了我所期望的：

// from clang
promise_type ctor
return_object ctor
~return_object dtor
~promise_type dtor

哪一个是对的？或者，只是标准没有规定承诺对象和返回对象的销毁顺序？