当requires子句失败时，函数尾部返回类型是否评估？

Question

下面的简单代码或哥德波特上的代码不是用clang编译的，而是使用gcc和Visual编译得很好。

当SFINAE在clang、gcc和Visual中失败时，不计算尾随返回类型decltype(foo(t)) of baz(T t)。

但是，当decltype(foo(t))子句在clang中失败时，bar(T t)的尾随返回类型仍将进行计算。使用gcc和Visual时，如果requires子句失败，则不计算尾随返回类型。哪个编译器在这个问题上是正确的？

谢谢。

#include <utility>
#include <type_traits>

template<typename T>
auto foo(T) {
    static_assert(std::is_integral<T>::value); // clang error: static_assert failed due to requirement 'std::is_integral<double>::value'
    return 5;
}
 
template<typename T> requires std::is_integral<T>::value
auto bar(T t) -> decltype(foo(t)) {
    return foo(t);
}

template<typename T> requires (!std::is_integral<T>::value)
auto bar(T) {
    return 1.5;
}

template<typename T, std::enable_if_t<std::is_integral<T>::value>* = nullptr>
auto baz(T t) -> decltype(foo(t)) {
    return foo(t);
}

template<typename T, std::enable_if_t<!std::is_integral<T>::value>* = nullptr>
auto baz(T) {
    return 1.5;
}

int main()
{
    bar(5.); // fails with clang, works with gcc and VS
    baz(5.); // works with clang, gcc and VS
}

Answer 1

这是CWG 2369，clang似乎还没有实现它。

这个问题中的例子(现在可以在[temp.deduct.general]/5中找到)不是在clang上编译，而是在gcc上编译。

template <class T> struct Z {
  typedef typename T::x xx;
};
template <class T> concept C = requires { typename T::A; };
template <C T> typename Z<T>::xx f(void *, T); // #1
template <class T> void f(int, T);             // #2

struct A {} a;

struct ZZ {
  template <class T, class = typename Z<T>::xx> operator T *();
  operator int();
};

int main() {
  ZZ zz;
  f(1, a);   // OK, deduction fails for #1 because there is no conversion from int to void*
  f(zz, 42); // OK, deduction fails for #1 because C<int> is not satisfied
}