Что это значит для «С сопрограммой без стеков, только подпрограмма верхнего уровня может быть приостановлена».

Я нашел это заявление от Вот. Сначала я был удивлен, потому что я считаю, что это делает сопрограммы без стеков практически бесполезными (а C + сопрограммы TS без стеков). Итак, я написал демо (в Visual Studio с использованием сопрограммы C ++ TS):

#include<experimental/coroutine>
#include<iostream>
#include<thread>
#include<mutex>
#include<future>
#include<chrono>

using namespace std;
using namespace std::chrono;
using namespace std::experimental;

class AsyncQueue {
public:
class Awaitable {
friend AsyncQueue;
AsyncQueue& mQueue;
coroutine_handle<> mCoroutineHandle;
Awaitable* mNext = nullptr;
public:
Awaitable(AsyncQueue& queue):mQueue(queue){}

bool await_ready() const noexcept {
return false;
}

bool await_suspend(coroutine_handle<> coroutineHandle) noexcept
{
mCoroutineHandle = coroutineHandle;
mQueue.enqueue(this);
return true;
}

void await_resume() noexcept {}
};
private:
mutex mMutex;
Awaitable* mHead = nullptr;
Awaitable* mTail = nullptr;
void enqueue(Awaitable* awaitable){
lock_guard<mutex> g{ mMutex };
if (mTail) {
mTail->mNext = awaitable;
mTail = awaitable;
}
else {
mTail = awaitable;
mHead = mTail;
}
}

Awaitable* dequeue() {
lock_guard<mutex> g{ mMutex };
Awaitable* result = mHead;
mHead = nullptr;
mTail = nullptr;
return result;
}

public:
Awaitable operator co_await() noexcept {
return Awaitable{ *this };
}

bool poll() {
Awaitable* awaitables = dequeue();
if (!awaitables) {
return false;
}
else {
while (awaitables) {
awaitables->mCoroutineHandle.resume();
awaitables = awaitables->mNext;
}
return true;
}
}
};AsyncQueue toBackgroundThread;
AsyncQueue toMainThread;

std::future<void> secondLevel(int id)
{
co_await toBackgroundThread;
cout << id << " run on " << this_thread::get_id() << endl;
co_await toMainThread;
cout << id << " run on " << this_thread::get_id() << endl;
}

std::future<void> topLevel() {
co_await secondLevel(1);
co_await secondLevel(2);
}

void listen(AsyncQueue& queue) {
while (true) {
if (!queue.poll()) {
this_thread::sleep_for(100ms);
}
}
}

int main() {
thread([]() {
listen(toBackgroundThread);
}).detach();

topLevel();

listen(toMainThread);
}

сопрограммная topLevel звонит два secondLevel (я считаю, что это подпрограммы не верхнего уровня), и это работает нормально.
Код выше печатает:

1 run on 16648
1 run on 3448
2 run on 16648
2 run on 3448

Из этого ответа утверждается, что This prohibits providing suspend/resume operations in routines within a general-purpose library. Я не вижу здесь никаких запретов.