[clang] Unnecessary instantiations of `constexpr` functions in `if constexpr (false)`

[eisenwave]

template <int N>
constexpr void f() {
    static_assert(N == 0);
}

void g() {
    if constexpr (false) {
        f<1>();
    }
}

This fails to compile: https://gcc.godbolt.org/z/G87rsPjWo (GCC accepts)

Removing constexpr from f() makes this compile, but it shouldn't matter either way. f() is not odr-used, not constant-evaluated, or otherwise needs to be instantiated.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Jan Schultke (Eisenwave)

```cpp template <int N> constexpr void f() { static_assert(N == 0); }

void g() {
if constexpr (false) {
f<1>();
}
}

This fails to compile: https://gcc.godbolt.org/z/G87rsPjWo (GCC accepts)

Removing `constexpr` from `f()` makes this compile, but it shouldn't matter either way. `f()` is not odr-used, not constant-evaluated, or otherwise needs to be instantiated.
</details>

[term-est]

Would something like this be a viable fix maybe?

[term-est]

Relevant #140576

[efriedma-quic]

Would something like this be a viable fix maybe?

No, need to handle it earlier; once it's marked odr-used, we can't change our mind later.

Note we do need to instantiate constexpr functions in discarded statements in some cases.

[shafik]

I want to say based on CWG2892 clang is wrong but I hesitate because everyone else disagrees with gcc: https://godbolt.org/z/dx9b8Pf9e

CC @zygoloid @hubert-reinterpretcast

[zygoloid]

f<1> would be needed for constant evaluation within an instantiation of the first arm of the if constexpr. Therefore the existence of the definition of f<1> would be considered to affect the semantics of the program. Therefore it would be implicitly instantiated.

This means that a hypothetical instantiation of the first arm of the if constexpr immediately following its definition would be ill-formed due to a construct that does not depend on a template parameter, so the program is ill-formed, no diagnostic required.

Generally, all templated entities are required to have valid instantiations, and this includes both arms of an if constexpr, even if the condition is not dependent. (If it didn't, we couldn't even diagnose syntactic errors in those arms.)

So I think Clang is not wrong to instantiate here.

[eisenwave]

I think you're right. The gotcha is that even though f<1> is never actually being constant evaluated, the mere fact it's a potentially-evaluated expression and that it's constexpr makes it needed.

I'm not sure if I understand the language design here, but Clang seems correct.