Clang behaves different with other compilers for constraint nested lambdas

[zyn0217]

Both were discovered in #133719, but the underlying causes are different from the original issue so I filed a separate one to track these.

1. The following code causes clang to crash, dating back to Clang 16 and up to trunk:

template <class T>
constexpr auto f{[] (auto arg) {
    return [a{arg}] {
        [] () requires (a == 1) {}();
    };
}};

int main() {
    f<int>(0);
}

https://compiler-explorer.com/z/Tq9xzrPns

2. Clang accepts the following code, while others don't (discovered by @shafik)

void f() {
    auto f{ 
      [](auto arg) {
        return [a = arg]() 
          requires (a == 1)
         { return a;};
      }
    };

    f(10);
}

https://godbolt.org/z/ncYx8q9f6

This has started since Clang 16.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Younan Zhang (zyn0217)

Both were discovered in #133719, but the underlying causes are different from the original issue so I filed a separate one to track these.

1. The following code causes clang to crash, dating back to Clang 16 and up to trunk:

template <class T>
constexpr auto f{[] (auto arg) {
    return [a{arg}] {
        [] () requires (a == 1) {}();
    };
}};

int main() {
    f<int>(0);
}

https://compiler-explorer.com/z/Tq9xzrPns

2. Clang accepts the following code, while others don't (discovered by @shafik)

void f() {
    auto f{ 
      [](auto arg) {
        return [a = arg]() 
          requires (a == 1)
         { return a;};
      }
    };

    f(10);
}

https://godbolt.org/z/ncYx8q9f6

This has started since Clang 16.

[frederick-vs-ja]

2. Clang accepts the following code, while others don't (discovered by @shafik)

void f() {
    auto f{ 
      [](auto arg) {
        return [a = arg]() 
          requires (a == 1)
         { return a;};
      }
    };

    f(10);
}

https://godbolt.org/z/ncYx8q9f6

The 2nd case is not a bug. It is an expected a possibly result of DR P2036R3 + P2579R0, which is currently only implemented by Clang.

[frederick-vs-ja]

Looks like that I was confused.

It seems that we should at least reject this

void f() {
  auto l2 = []<class = void>() {
    return [a = 10]() requires (a == 1) { return a; };
  }();
}

[frederick-vs-ja]

This one is perhaps valid, but seemingly causes infinite recursion in Clang (Godbolt link).

struct ConvToOne {
  constexpr operator int() const { return 1; }
};

void g() {
  auto l2 = []<class = void>() {
    return [a = ConvToOne{}]() requires (a == 1) { return a; };
  }();
  l2();
}

[shafik]

CC @cor3ntin