Why can't lambda, when cast to function pointer, be used in constexpr context?

Question

Consider an example:

template <void (*Foo)()>
struct S {
};

int main() {
    struct A {
        static void x() { }
    };
    S<&A::x> s;
}

The code compiles in clang, gcc argue that x doesn't have a linkage... For quite similar example just when using lambda expression:

template <void (*Foo)()>
struct S {
};

int main() {
    auto lambda = []{};
    S<+lambda> s;
}

Both gcc and clang agree not to compile the code: according to gcc the function returned by unary + doesn't have linkage, clang states in contrast that cast operator to the function isn't declared as constexpr. Are there any reasons to disallow lambda cast to function pointer to be used in constexpr context?

Find below errors produced by compilers and the live demos:

gcc:

prog.cc:7:14: error: 'main()::::_FUN' is not a valid template argument for type 'void (*)()' because 'static constexpr void main()::::_FUN()' has no linkage

clang:

prog.cc:7:8: note: non-constexpr function 'operator void (*)()' cannot be used in a constant expression

Answer 1

Clang hasn't implemented constexpr lambdas yet.

GCC is behind in other ways. [temp.arg.nontype]/2's only interesting constraint is that the argument shall be a constant expression. But [expr.const]/(5.2) makes it one, so that's perfectly valid. Perhaps GCC didn't implement N4198 yet, which eliminated the linkage requirement.

Note that both constexpr lambdas and no-linkage function pointer template arguments are post C++14 features.