lambda call should propagate as immediate function when the body is immediate-escalating expression

[changkhothuychung]

Should clang not generate the lambda call operator for this lambda call?

According to https://eel.is/c++draft/expr.const#18, the call operator of a lambda that is not declared with the consteval specifier is an immediate-escalating function (1)

From https://eel.is/c++draft/expr.const#17, the call to f() is an immediate-escalating expression. (2)

(1) and (2) will make the call to l() an immediate function and assembly code should not generate assembly code for the call operator. gcc seems to do it

consteval auto f()
{
    return 1; 
}

auto l = [](){
    return f(); 
};


int main()
{
    auto x = l();
}

https://godbolt.org/z/vn6fh1fE5

[MitalAshok]

The lack of code gen with GCC is an optimization. GCC still also allows auto lp = &decltype(l)::operator();, showing that l's call operator is not marked consteval in GCC too.

This should be the expected behaviour as f() is an immediate invocation that is a constant expression in its own right, so it's not immediate-escalating (https://eel.is/c++draft/expr.const#17.2)

[llvmbot]

@llvm/issue-subscribers-clang-codegen

Author: Nhat Nguyen (changkhothuychung)

Should clang not generate the lambda call operator for this lambda call?

According to https://eel.is/c++draft/expr.const#18, the call operator of a lambda that is not declared with the consteval specifier is an immediate-escalating function (1)

From https://eel.is/c++draft/expr.const#17, the call to f() is an immediate-escalating expression. (2)

(1) and (2) will make the call to l() an immediate function and assembly code should not generate assembly code for the call operator. gcc seems to do it

consteval auto f()
{
    return 1; 
}

auto l = [](){
    return f(); 
};


int main()
{
    auto x = l();
}

https://godbolt.org/z/vn6fh1fE5

[changkhothuychung]

The lack of code gen with GCC is an optimization. GCC still also allows auto lp = &decltype(l)::operator();, showing that l's call operator is not marked consteval in GCC too.

This should be the expected behaviour as f() is an immediate invocation that is a constant expression in its own right, so it's not immediate-escalating (https://eel.is/c++draft/expr.const#17.2)

Oh right. Now I think more about it, can you give me an example which is an immediate invocation and not a constant expression? I missed the constant expression part when I created this issue, and now I cant think of one example. Thanks!

[MitalAshok]

@changkhothuychung https://godbolt.org/z/doYzMMKb6

consteval auto f(int) {
    return 1; 
}

auto l = [](int i) {
    return f(i);  // Change to "f(0)" and it's no longer immediate-escalating
};

int main() {
    auto x = l(0);
}