<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/114755>114755</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            [clang][regression] lambda call in unevaluated context in generic lambda in template function fails from clang 15 onwards
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            clang
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          wanghan02
      </td>
    </tr>
</table>

<pre>
    Example code could be found below or on [godbolt](https://godbolt.org/z/crefWM4MY). clang 14, gcc and MSVC all compile fine. clang 15 onwards fail.

The problem is triggered only if `tc_lazy` is called in a template function and the lambda in `tc_lazy` is a generic lambda.

```
#include <type_traits>
#include <utility>

#define HYBRIDSTR(str) \
        [](auto t) constexpr noexcept -> decltype(auto) { \
                using ArgCharT = typename decltype(t)::type; \
                if constexpr(std::is_same<ArgCharT, char>::value) { \
                        return str; \
                } else if constexpr(std::is_same<ArgCharT, wchar_t>::value) { \
                        return L ## str; \
                } else if constexpr(std::is_same<ArgCharT, char16_t>::value) { \
                        return u ## str; \
                } else { \
                        static_assert(std::is_same<ArgCharT, char32_t>::value); \
                        return U ## str; \
                } \
        }

namespace tc {
    template<typename T>
    constexpr std::conditional_t<
        std::is_rvalue_reference<T&&>::value,
 std::decay_t<T>,
        T
    > lvalue_or_decay(T&& t) {
 return std::forward<T>(t);
    }

        namespace make_lazy_adl {
                template<typename Func>
                struct make_lazy : Func {
                        constexpr explicit make_lazy(Func func) noexcept : Func(std::move(func)) {}

                        constexpr operator decltype(std::declval<Func const&>()())() const&& {
                                return (*this)();
                        }
                };
        }
        using make_lazy_adl::make_lazy;
        namespace lazy_detail {
                template<bool bReference, typename T>
                decltype(auto) lvalue_or_decay(T&& t) noexcept {
                        if constexpr (bReference) {
                                return tc::lvalue_or_decay(std::forward<T>(t));
                        }
                }
        }
}

#define tc_lazy( ... ) tc::make_lazy([&](auto&&...) -> decltype(auto) { \
                if constexpr (std::is_reference<decltype((__VA_ARGS__))>::value) { \
                        return tc::lazy_detail::lvalue_or_decay<std::is_reference<decltype((__VA_ARGS__))>::value>(__VA_ARGS__); \
                } else { \
                        return __VA_ARGS__; \
                } \
        })

template<typename Char>
auto foo() {
    return tc_lazy(HYBRIDSTR("abc")(std::type_identity<Char>()))(); // fails in template function from clang 15 onwards
}

void bar() {
 tc_lazy(0)();
 tc_lazy(HYBRIDSTR("abc")(std::type_identity<char16_t>()))(); // compiles
    foo<char16_t>();
}
```
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJysV0uP2zYQ_jX0ZRBDpixbOvjgteO2QHPZbFPkZFDUyGZLkQZJ7SO_viD1XFtJdtEEC8eW5vHNNw8OmbXipBA3JLkjyX7GanfWZvPE1OnMVERnuS5eNh-fWXWRCFwX_qOWBeQIpa6V_yL1E2gDWgFJ7k66yLV0JNkTmp6du1gSbwk9EHpoX821ORF6-EbogRss__60_PSV0GwOXDJ1gsWS0B2cOAemCvj0-csOmJTAdXUREqEUCnvRBLR6YqawUDIh5yTak2jbfD6cES5G5xIrEBacEacTGixAK_kCogSyihw_SvbthawiL8KZlFiAUMDAYXWRzCGUteJOaBXAuDOCZFVeMC91Y4DBCRUawVuhV3jIKmr_mp80ForLukAg8c69XPDoDBPOkvjjlETthBTuZXjbyRToGYHfv97d_7H__HBPaGqdITQDkuw62azJLqEpq50G519zrazD54sBpfGZ48XBBxJ_hAK59Hha4WBpfffaWpTVVqgTbM1pd2bmAUi8B6-kWIVjC96Tz3-8DQ_iGzuiHIAE6EUjLuzRsgpJvOt8-KrgZ2Y8BUHkkckavwOPRJlBVxsFnoxbt2S9B5QW4X3-nzyAo3snhD-B0JjQ-Ndi8VAWq3eDqd8IZtqIdcwJfmTWonFvwxjTCYxTnnuIf_0c4qtH6_24J3wJ2gvjCI77KJqnANA3ddtwoVYf-o7yEkNP9IFxrQrhJwCTPo7dIOz_jeM3IbijwRINKu7dPBC68n9X4XdGeu0COXsJ5gMeeuXlYfjpO1Q2jrQ5Bj1C09ZP09hDzH0LtG5Kbfy07N207Tmi6IpLEmUDnRX7F8O4O7JCDl6apExxe6gVHw2spn5Mzd1gCki8DXLX9kiUDcnA54sUXIz0CE2Dlh_PPuZ-hHX2xrVZ6Uc_i1rZjqKbSK-96gsa5rQZz7NxxnwaSLwLOIJWm2maBi_NZ_tlEKCriVCH2g_iW3cWdjAS34gP2LufY5nR22ZMv8pcy0nP5EhzyHUQLtAx8aNM51pLyO_7gqc7mGisRm3iWPlJHQ85veFrPCk9ZWMM2Q_5dbyJ_9b3T7rkjXm4TcJVnfUndrc70BTm8zl44B24cZn7k5uuhsO7YWg-n3uFdxzY15S9mlyjkTWyRmh6PH7ZHrf3v30-HjsS3nXa9HQP9TTNf7z7NYBCwq6E3n3KteDHZt52DNFsnOupmbhrN5ggEJaxUut2Rrw6rHoCu0IYb3iEUpZzQmkzJHrqwh4pClQu7Iq7ztswjIaZAs1SHjZn6_fZ2523NLq6WbUny_pRiwJyZm4iGfBHtwPtf0Y33oB-FGF7dbADuZ7zKf2-w_vouq19VmziIoszNsPNYh1H6yhdRdnsvEnTJaesXLE4Y2kUrVjOkmi5LvN0uSgyFs3EhkZ0uVhEyyilMc3mWcqjdUJjzMt0gRkjywgrf32R8rHyl6OZsLbGzWKxXCfJTLIcpQ33M0pDMjwzyX5mNl7hQ16fLFlGUlhnBxNOOBkudY1GsifJncGTQWuFViTZdxcZf-vx2a8V-g5iDgs_KBw-O__49Y3mO2USKmiyWGa1kZurW6Bw5zqfc10RevB42_8-XIz-B7kj9BDit4QeWgoeN_S_AAAA__8uuDcs">