lambda: immediate function 'operator()<int>' used before it is defined

[Fedr]

This C++23 program

#include <memory>

consteval auto func1() {
    return std::make_unique<int>();
}

template <typename T>
consteval void func2() {
    [](auto) -> void {
        func1();
    }(0);
}

int main() {
    func2<int>();
}

is accepted by GCC, but Clang prints weird error:

error: immediate function 'operator()<int>' used before it is defined
    9 |     [](auto) -> void {

Online demo: https://gcc.godbolt.org/z/Kb8M7c3nb

Original discussion: https://stackoverflow.com/q/79221393/7325599

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Fedor Chelnokov (Fedr)

This C++23 program ```c++ #include <memory>

consteval auto func1() {
return std::make_unique<int>();
}

template <typename T>
consteval void func2() {
-> void {
func1();
}(0);
}

int main() {
func2<int>();
}

is accepted by GCC, but Clang prints weird error:

error: immediate function 'operator()<int>' used before it is defined
9 | -> void {

Online demo: https://gcc.godbolt.org/z/Kb8M7c3nb

Original discussion: https://stackoverflow.com/q/79221393/7325599
</details>

[tbaederr]

Well, the full diagnostic output gives a little more context:

<source>:11:5: error: immediate function 'operator()<int>' used before it is defined
   11 |     [](auto) -> void {
      |     ^
<source>:11:5: note: in instantiation of function template specialization 'func2()::(anonymous class)::operator()<int>' requested here
<source>:18:5: note: in instantiation of function template specialization 'func2<int>' requested here
   18 |     func2<int>();
      |     ^
<source>:11:5: note: 'operator()<int>' defined here
   11 |     [](auto) -> void {
      |     ^
<source>:13:9: note: 'operator()<int>' is an immediate function because its body contains a call to a consteval function 'func1' and that call is not a constant expression
   13 |         func1();
      |         ^~~~~~~

Clang can't do std::make_unique at compile time, so the call to func1() fails.

The "immediate function is used before it's defined" error is just a consequence of that. CC @cor3ntin since this relates to immediate-escalating functions.

Edit: Hmm, looks like make_unique does work: https://godbolt.org/z/dzEaxTMqb

[LHLaurini]

For context, from the original discussion, the following also results in the same error:

#include <string>

consteval auto func1()
{
    return std::string();
}

template <typename T>
consteval auto func2()
{
    [](auto) -> int {
        func1();
        return {};
    }(0);
}

consteval auto func3()
{
    func2<int>();
}

So it's not specific to std::unique_ptr. The example below doesn't use the STL, but also produces the same error:

class Thing
{
public:
    constexpr Thing() : ptr(new int) {}
    constexpr ~Thing() { delete ptr; }

private:
    int* ptr;
};

consteval auto func1()
{
    return Thing();
}

template <typename T>
consteval auto func2()
{
    [](auto) -> int {
        func1();
        return {};
    }(0);
}

consteval auto func3()
{
    func2<int>();
}

[tbaederr]

Yeah, if you play around with the code a bit (and use the values instead of discarding them), both compilers reject with the same reasoning: https://godbolt.org/z/fhvoP4P1b

[LHLaurini]

This issue seems to only happen in a very specific situation. For instance, the original example compiles if you do any one of these:

• Move the std::make_unique call to func2
• Remove the trailing return type (-> int) and return int{} instead
• Remove the auto parameter so the lambda's operator() is not a template
• Remove template <typename T> so func2 is not a template
• Remove consteval from func1
• Move func1() to outside the lambda, so the lambda is not an immediate function
• Replace consteval with constexpr
• Add consteval to the lambda, making it explicitly immediate (thanks to @Fedr for finding this one)

[LHLaurini]

Yeah, if you play around with the code a bit (and use the values instead of discarding them), both compilers reject with the same reasoning: https://godbolt.org/z/fhvoP4P1b

Sure, but that behavior is correct.

[wusatosi]

#include <string>

consteval auto func1() {
    return std::string();
}

int main() {
    auto c = func1();
}

I don't know if this is correct approach, but I don't think returning a std::string r-value is constexpr.

Same goes for

#include <memory>

consteval auto func1() {
    return std::make_unique<int>(5);
}

int main() {
    auto c = func1();
}

This is consistent with both gcc and clang: https://godbolt.org/z/WY9e6Pxv9

I don't think the lambda is relevant here?

[t3nsor]

The lambda is relevant because consteval should be able to "propagate" through it up to func2. And the unique_ptr is destroyed before func2 returns, so the overall call to func2 should be considered a constant expression.