On cppreference I read the following (emphasis mine):

Falling off the end of the coroutine is equivalent to co_return;, except that the behavior is undefined if no declarations of return_void can be found in the scope of Promise.

But clang 18.1.0 behaves differently in regards to destruction of local variables. When I fall off the end of a coroutine, the local variables get destructed, then return_value is called. When I use co_return;, return_value is called before destruction of local variables.

My question is: is cppreference making a stronger statement about co_return; vs falling off than the actual standard is? Is clangs behavior a bug, or aligned with the standard?

Here a small sample that shows the difference, along with a godbolt for your convenience:

#include <iostream>
#include <coroutine>

struct Coroutine {
    struct promise_type {
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }

        Coroutine get_return_object() { return {}; }

        void unhandled_exception(){}
        void return_void() {
            std::cout << "return_void calledn";
        }
    };
};

struct LogOnDestruct {
    ~LogOnDestruct() {
        std::cout << "Destructedn";
    }
};

Coroutine foo() {
    LogOnDestruct logger{};
    co_await std::suspend_never{};
}
Coroutine bar() {
    LogOnDestruct logger{};
    co_return;
}

int main() {
    foo();
    bar();

    return 0;
}