[Clang] constexpr variables wrongfully treated as captures in certain lambdas

[yuxuanchen1997]

Clang currently rejects the following program by saying "error: variable 'XXXcap' cannot be implicitly captured in a lambda with no capture-default specified"

template <typename...>
struct tag_t {};

template <auto...>
struct vtag_t {};

template <auto... V>
inline constexpr vtag_t<V...> vtag{};

template <typename T>
constexpr bool alt = true;

template <typename = void>
auto vtag_safety_of_non_stored_args() {
  return []<typename T>(tag_t<T>) {
    return vtag<[]() {
      constexpr bool XXXcap = alt<T>;
      if constexpr (XXXcap) {
        return vtag<>;
      } else {
        return vtag<XXXcap>;
      }
    }>;
  }(tag_t<int>{});
}

void check() {
  vtag_safety_of_non_stored_args();
}

This seems wrong. As XXXcap here is not a capture. GCC and MSVC seem to have no problem with this.

See compiler explorer: https://godbolt.org/z/7rqcfGe7x

[llvmbot]

@llvm/issue-subscribers-c-20

Author: Yuxuan Chen (yuxuanchen1997)

Clang currently rejects the following program by saying "error: variable 'XXXcap' cannot be implicitly captured in a lambda with no capture-default specified" ```cpp template <typename...> struct tag_t {};

template <auto...>
struct vtag_t {};

template <auto... V>
inline constexpr vtag_t<V...> vtag{};

template <typename T>
constexpr bool alt = true;

template <typename = void>
auto vtag_safety_of_non_stored_args() {
return []<typename T>(tag_t<T>) {
return vtag< {
constexpr bool XXXcap = alt<T>;
if constexpr (XXXcap) {
return vtag<>;
} else {
return vtag<XXXcap>;
}
}>;
}(tag_t<int>{});
}

void check() {
vtag_safety_of_non_stored_args();
}

This seems wrong. As `XXXcap` here is not a capture. GCC and MSVC seem to have no problem with this.
 
See compiler explorer: https://godbolt.org/z/7rqcfGe7x

</details>

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Yuxuan Chen (yuxuanchen1997)

Clang currently rejects the following program by saying "error: variable 'XXXcap' cannot be implicitly captured in a lambda with no capture-default specified" ```cpp template <typename...> struct tag_t {};

template <auto...>
struct vtag_t {};

template <auto... V>
inline constexpr vtag_t<V...> vtag{};

template <typename T>
constexpr bool alt = true;

template <typename = void>
auto vtag_safety_of_non_stored_args() {
return []<typename T>(tag_t<T>) {
return vtag< {
constexpr bool XXXcap = alt<T>;
if constexpr (XXXcap) {
return vtag<>;
} else {
return vtag<XXXcap>;
}
}>;
}(tag_t<int>{});
}

void check() {
vtag_safety_of_non_stored_args();
}

This seems wrong. As `XXXcap` here is not a capture. GCC and MSVC seem to have no problem with this.
 
See compiler explorer: https://godbolt.org/z/7rqcfGe7x

</details>

[snarkmaster]

I initially ran into this problem when my code had if constexpr (alt<T>) with true alt<T>, but the branch wasn't being taken. I then lifted alt<T> to XXXcap, and the above (incorrect) error appeared. @yuxuanchen1997 helped reduce the repro that you see here.

With Yuxuan's reduced code, I just tried to reproduce the initial "wrong branch being taken" behavior, and got a different manifestation of this bug:

#include <type_traits>

template <typename...>
struct tag_t {};

template <auto...>
struct vtag_t {};
template <auto... V>
inline constexpr vtag_t<V...> vtag{};

template <typename T>
constexpr bool alt = true;

template <typename = void>
auto branch_on_alt() {
  return []<typename T>(tag_t<T>) {
    return vtag<[]() {
      if constexpr (alt<T>) {
        return vtag<1>;
      } else {
        return vtag<0>;
      }
    }()>;
  }(tag_t<int>{});
}

static_assert(std::is_same_v<
  decltype(branch_on_alt()), vtag_t<vtag<1>>>);

Again, the error (see https://godbolt.org/z/e364M1v9T) does not reproduce on gcc or MSVC. But maybe the new message has some additional hint for why this is happening?

return type 'vtag_t<0>' must match previous return type 'vtag_t<1>' when lambda expression has unspecified explicit return type

So, rather than "the wrong branch is taken", it seems like clang is attempting to compile both if constexpr branches, which sounds incorrect to me.

---

Edit: Yes, lifting the inner lambda to a function works around the issue:

template <typename T>
constexpr auto lifted_lambda() {
  if constexpr (alt<T>) {
    return vtag<1>;
  } else {
    return vtag<0>;
  }
}

template <typename = void>
auto branch_on_alt() {
  return []<typename T>(tag_t<T>) {
    return vtag<lifted_lambda<T>()>;
  }(tag_t<int>{});
}