[Bug c++/95540] New: [coroutine] coroutine_traits<> lookup for lambdas

[bruck.michael at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95540

            Bug ID: 95540
           Summary: [coroutine] coroutine_traits<> lookup for lambdas
           Product: gcc
           Version: 10.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: bruck.michael at gmail dot com
  Target Milestone: ---

This fails on gcc and clang

gcc: unable to find the promise type for this coroutine
clang: ...coroutine_traits<.., const (lambda at <source>:30:12) &>' has no
member named 'promise_type'

https://gcc.godbolt.org/z/kXzEZW

The clang error hints that the lookup is performed with P1 being the lambda
closure type. I suspect gcc does the same (there is potential for a more
detailed diagnostic here). This makes it impossible to use coroutine_traits<>
with lambdas.

n4835:
[dcl.fct.def.coroutine]
"The promise type of a coroutine is std::coroutine_traits<R, P1, . . . ,
Pn>::promise_type, where R is the return type of the function, and P1 . . . Pn
are the sequence of types of the function parameters, preceded by the type of
the implicit object parameter (12.4.1) if the coroutine is a non-static member
function. The promise type shall be a class type."

While a lambda does have a non-static member operator() the lambda expression
creates a closure object, not a member function. In any case either the
standard or the interpretation of the compilers prevents the use of
coroutine_traits<> for lambdas without a discernible benefit.


#ifndef __clang__
#include <coroutine>
#else
#include <experimental/coroutine>
namespace std { using namespace experimental; }
#endif

#include <cstdio>

struct pt
{
    using handle_t = std::coroutine_handle<pt>;
    auto get_return_object() noexcept { return handle_t::from_promise(*this); }

    std::suspend_never initial_suspend() const noexcept { return {}; }
    std::suspend_never final_suspend() const noexcept { return {}; }
    void return_void() const noexcept {}
    void unhandled_exception() const noexcept {}
};

template <> struct std::coroutine_traits<pt::handle_t>
    { using promise_type = pt; };

static pt::handle_t foo()
{ 
    printf("from function\n");
    co_return;
}

auto bar = []() -> pt::handle_t
{ 
    printf("from lambda\n");
    co_return;
};

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