MSVC bug? - Returned inner lambda with non-init-capture of outer lambda's by-ref parameter causes C2131 when outer lambda is passed a plain function

Here's the live minimal example demonstrating the issue, copied below along with error:

constexpr auto foo = [](auto const& p) { return 
{ return 1; }; };

void bar(){}
constexpr auto baz = foo(bar); // C2131

<source>(6): error C2131: expression did not evaluate to a constant
<source>(2): note: failure was caused by a read of an uninitialized symbol
<source>(2): note: see usage of '<lambda_833637519c89a13e2555ac846bc40c61>::()::<lambda_13c809781a1aa438f693875c73cfce81>::p'
<source>(6): note: the call stack of the evaluation (the oldest call first) is
<source>(6): note: while evaluating function '<lambda_833637519c89a13e2555ac846bc40c61>::()::<lambda_13c809781a1aa438f693875c73cfce81> <lambda_833637519c89a13e2555ac846bc40c61>::operator ()<void(void)>(void (__cdecl &)(void)) const'
<source>(2): note: while evaluating function '<lambda_833637519c89a13e2555ac846bc40c61>::()::<lambda_13c809781a1aa438f693875c73cfce81>::<lambda_13c809781a1aa438f693875c73cfce81>(void (__cdecl &)(void))'
Compiler returned: 2

Some possible workarounds:

• make bar a function object, i.e. constexpr auto bar = []{};
• change foo's param type to be by-value, i.e. constexpr auto foo = [](auto p) { return

  { return 1; }; };

• use init-capture for the inner lambda, i.e. constexpr auto foo = [](auto const& p) { return

  { return 1; }; };

• make baz non-constexpr, i.e. const auto baz = foo(bar);

Is it indeed a bug in MSVC¹ or a non-conformance in the compilers that accept the code above?

(¹) I've used x64 msvc v19.35, but x64 msvc v19.14 seems to be ok with the code.

[expr.prim.lambda.capture]p10:

> The type of such a data member is the referenced type if the entity is a reference to an object, an lvalue reference to the referenced function type if the entity is a reference to a function, or the type of the corresponding captured entity otherwise.

(emphasis mine)

So with the closure types explicitly written out, it might look something like this:

struct __foo_lambda_type {
    template<typename T>
    constexpr auto operator()(T const& p) const {
        struct __inner_lambda_type {
            // (p is a reference to a function, capture by value creates a reference)
            T& p;

            constexpr auto operator()() const {
                return 1;
            }
        };
        return __inner_lambda_type{ p };
    };
};

constexpr auto foo = __foo_lambda_type{};

void bar(){}
constexpr auto baz = foo.operator()<void()>(bar);

... Which also doesn't compile in MSVC

It seems like the MSVC bug is that it can't use structs with function references in constant expressions

https://godbolt.org/z/5E6KP6boP

void bar();

struct function_reference {
    void(&ref)();
    constexpr function_reference(void(&ctor_ref)()) :
        ref(ctor_ref)  // line (6)
        {}
};

constexpr auto f(void(&local_ref)()) {
    auto x = function_reference{local_ref};  // line (11)
    return x;
};

constexpr auto x = f(bar);  // line (15)

(15): error C2131: expression did not evaluate to a constant
( 6): note: failure was caused by a read of an uninitialized symbol
( 6): note: see usage of 'function_reference::ref'
(15): note: the call stack of the evaluation (the oldest call first) is
(15): note: while evaluating function 'function_reference f(void (__cdecl &)(void))'
(11): note: while evaluating function 'function_reference::function_reference(void (__cdecl &)(void))'

The workaround is to capture a function pointer.

does this because it is equivalent to auto lambda_member_p = p, where lambda_member_p is deduced to have a function pointer type if p is a function reference.