Incorrect promise constructor used with lambda coroutines

[landelare]

In the C++20 program below, the lambda has a non-static member operator(), but its object parameter is skipped when looking for a promise constructor overload. This results in the first overload being called, and an output of Wrong.

Tested on 18.1.5 and 19.0.0git (b5af667). When compiled with GCC or MSVC, the output is Correct, as expected.

Additionally, removing the second constructor should make the resulting program no longer compile, which is the case with MSVC and GCC, but not Clang.

#include <coroutine>
#include <iostream>

struct coro {};

struct promise {
    promise(int) {std::cout << "Wrong\n";}
    promise(auto, int){std::cout << "Correct\n";} // Remove me for an additional test case!

    coro get_return_object() {return {};}
    std::suspend_never initial_suspend() {return {};}
    std::suspend_never final_suspend() noexcept {return {};}
    void return_value(int) {}
    void unhandled_exception() {}
};

template<typename... T>
struct std::coroutine_traits<coro, T...> {
    using promise_type = promise;
};

int main() {
    int x = 0;
    [x](int y) -> coro { co_return x + y; }(1);
}

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Laura Andelare (landelare)

In the C++20 program below, the lambda has a non-static member operator(), but its object parameter is skipped when looking for a promise constructor overload. This results in the first overload being called, and an output of `Wrong`.

Tested on 18.1.5 and 19.0.0git (b5af667). When compiled with GCC or MSVC, the output is Correct, as expected.

Additionally, removing the second constructor should make the resulting program no longer compile, which is the case with MSVC and GCC, but not Clang.

#include <coroutine>
#include <iostream>

struct coro {};

struct promise {
    promise(int) {std::cout << "Wrong\n";}
    promise(auto, int){std::cout << "Correct\n";} // Remove me for an additional test case!

    coro get_return_object() {return {};}
    std::suspend_never initial_suspend() {return {};}
    std::suspend_never final_suspend() noexcept {return {};}
    void return_value(int) {}
    void unhandled_exception() {}
};

template<typename... T>
struct std::coroutine_traits<coro, T...> {
    using promise_type = promise;
};

int main() {
    int x = 0;
    [x](int y) -> coro { co_return x + y; }(1);
}

[llvmbot]

@llvm/issue-subscribers-coroutines

Author: Laura Andelare (landelare)

In the C++20 program below, the lambda has a non-static member operator(), but its object parameter is skipped when looking for a promise constructor overload. This results in the first overload being called, and an output of `Wrong`.

Tested on 18.1.5 and 19.0.0git (b5af667). When compiled with GCC or MSVC, the output is Correct, as expected.

Additionally, removing the second constructor should make the resulting program no longer compile, which is the case with MSVC and GCC, but not Clang.

#include <coroutine>
#include <iostream>

struct coro {};

struct promise {
    promise(int) {std::cout << "Wrong\n";}
    promise(auto, int){std::cout << "Correct\n";} // Remove me for an additional test case!

    coro get_return_object() {return {};}
    std::suspend_never initial_suspend() {return {};}
    std::suspend_never final_suspend() noexcept {return {};}
    void return_value(int) {}
    void unhandled_exception() {}
};

template<typename... T>
struct std::coroutine_traits<coro, T...> {
    using promise_type = promise;
};

int main() {
    int x = 0;
    [x](int y) -> coro { co_return x + y; }(1);
}

[ChuanqiXu9]

It looks like this can be handled by #84519

[landelare]

I've confirmed that this is still present in 19.1.0.

[hach-que]

Indeed, I can confirm clang trunk is still affected by this. Here's a reproduction case on Godbolt where you can see the incorrect parameters cause the tuple assignment not to match:

no known conversion from 'tuple<const std::basic_string &, (no argument)>' to 'const tuple<const (lambda at :91:14) &, const std::basic_string &>' for 1st argument

Here's a full copy of the source code that reproduces it in case that Godbolt link becomes invalid. This compiles on both GCC trunk and MSVC 19.latest:

#include <coroutine>
#include <tuple>
#include <chrono>
#include <functional>
#include <deque>

template<typename T>
class ls_task
{
public:
    ls_task() = default;
    ls_task(const ls_task&) = default;
    ls_task(ls_task&&) = default;
    ~ls_task() = default;

    bool await_ready() const
    {
        return false;
    }

    void await_suspend(std::coroutine_handle<> h) const
    {
    }

    auto await_resume() const
    {
    }
};

template<typename TaskType, typename ReturnType, typename...Args>
struct ls_promise
{
private:
    std::tuple<Args const&...> args;

public:
    template<typename... T>
    ls_promise(T const&... in_args)
        : args(std::forward_as_tuple(in_args...))
    {
    }
    ls_promise(ls_promise const&) = delete;
    void operator=(ls_promise const&) = delete;
    ls_promise(ls_promise&&) = delete;
    void operator=(ls_promise&&) = delete;
    ~ls_promise() = default;

    ls_task<ReturnType> get_return_object()
    {
        return {};
    }

    std::suspend_never initial_suspend() noexcept
    {
        return {};
    }

    std::suspend_never final_suspend() noexcept
    {
        return {};
    }

    void return_value(const ReturnType &value)
    {
    }

    void unhandled_exception()
    {
    }
};

template<typename ReturnType, typename LambdaType, typename...Args>
struct std::coroutine_traits<ls_task<ReturnType>, LambdaType&, Args...>
{
    using promise_type = ls_promise<
        ls_task<ReturnType>, 
        ReturnType, 
        LambdaType&, 
        Args...>;
};

std::deque<ls_task<std::time_t>> pending_tasks;

ls_task<std::time_t> delay() {
    return pending_tasks.emplace_back();
}

void push(int i) {
    auto p0 = std::chrono::system_clock::to_time_t(
        std::chrono::system_clock::now());
    auto l = [p0](std::string k) -> ls_task<std::time_t> {
        co_await delay();
        co_await ls_task<int>();
        printf("%s\n", k.c_str());
        co_return p0 * 2;
    };
    auto task = l("test");
    pending_tasks.push_back(task);
}

int main() {
    for (int i = 0; i < 10; i++) {
        push(i);
    }

    while (!pending_tasks.empty()) {
        auto next_task = pending_tasks[0];
        pending_tasks.pop_front();
        //next_task.state->ready = true;
        //next_task.state->call_when_ready(0);
    }
}

[landelare]

Still present in 20.1.0.

[ameaninglessname]

Could we get an ETA for this? Isn't this a critical defect to Clang?