[Clang] Fails to diagnose `return;` in non-void function in class template

[Xniao]

Program

template <class T> struct S {
  T f;
  S() : f() {}
  S foo() {
    return;
  }
};

int main() {
    S<int> f,g;
}

Repro: https://godbolt.org/z/cf7oTvqfa
✅ GCC correctly rejects with a diagnostic.
❌ Clang accepts, unless the function is called.
When the return type of function foo is changed from S to int, Clang does reject the code.

[efriedma-quic]

This is a case where there's no diagnostic required, but it might be nice if we can diagnose more cases.

(We have to be careful that we don't reject, for example, template<typename T> T f() { return; }.)

[AaronBallman]

I think we're considering it a dependent member function because the return type is S and that class isn't yet instantiated, so we don't diagnose. When the return type is int, then the member function isn't dependent.

[efriedma-quic]

Right... S is actually S<T>, which is dependent. We currently don't try to analyze dependent types at all.

There's a question of how hard we want to try... for example, we can also prove the following functions are invalid, but the deeper we get, the harder it is to generalize, or give a useful explanation.

template <class T> void f() {
  // The type of a variable must be a complete object type.
  T t;
  return t;
}
template<class T> T f2(T) {
  // T can't be void because functions can't have void arguments.
  return;
}

[AaronBallman]

Right... S is actually S<T>, which is dependent. We currently don't try to analyze dependent types at all.

Yup!

There's a question of how hard we want to try... for example, we can also prove the following functions are invalid, but the deeper we get, the harder it is to generalize, or give a useful explanation.

template <class T> void f() {
  // The type of a variable must be a complete object type.
  T t;
  return t;
}
template<class T> T f2(T) {
  // T can't be void because functions can't have void arguments.
  return;
}

That's what I was thinking about as well. We could probably make things smarter, but it's hard to reason about what the mental model is. Currently, we're pretty consistent: don't check anything which is value or type dependent until after there's an instantiation to check against.