Clang rejects valid program with default argument

[ranaanoop]

The following valid program is rejected by clang. Demo

template <typename T> class Container {                                                                                                                                                                                                                                                    
    public:                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                    
        template<typename U = T> 
        std::enable_if_t<std::is_same_v<T, int>> foo(const T&)
        {
            
        }
};                                                                                                                                                                                                                                                              

template<typename T>
void func(T&& callable)
{
    Container<int> c;
    (c.*callable)(4);
}
int main(){                                                                                                                                                                                                                                
                                                                                                                                                                                                                                             
  func(&Container<int>::foo); //works with gcc but not with clang and msvc

} 

[llvmbot]

@llvm/issue-subscribers-clang-frontend

[inclyc]

This code may pass compilation by explicitly specify the template argument of func or remove type traits.

Give the type

Link: https://godbolt.org/z/6rvcssTr7

#include <iostream>
#include <type_traits>                                                                                                                                                                                                                                       

template <typename T> class Container {                                                                                                                                                                                                                                                    
    public:                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                    
        template<typename U = T> 
        std::enable_if_t<std::is_same_v<T, int>> foo(const T&) {
            
        }
};                                                                                                                                                                                                                                                              

template<typename T>
void func(T&& callable) {
    Container<int> c;
    (c.*callable)(4);
}
int main(){                                                                                                                                                                                                                                
                                                                                                                                                                                                                                             
  func<void (Container<int>::*)(int const&)>(&Container<int>::foo); //works with gcc but not with clang and msvc
}  

- func(&Container<int>::foo); //works with gcc but not with clang and msvc
+ func<void (Container<int>::*)(int const&)>(&Container<int>::foo); //works with gcc but not with clang and msvc

No type traits

Link: https://godbolt.org/z/eh8KEc11K

#include <iostream>
#include <type_traits>                                                                                                                                                                                                                                       

template <typename T> class Container {                                                                                                                                                                                                                                                    
    public:                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                    
        void foo(const T&) {
            
        }
};                                                                                                                                                                                                                                                              

template<typename T>
void func(T&& callable) {
    Container<int> c;
    (c.*callable)(4);
}
int main(){                                                                                                                                                                                                                                
                                                                                                                                                                                                                                             
  func(&Container<int>::foo); //works with gcc but not with clang and msvc
}  

- template<typename U = T> 
-        std::enable_if_t<std::is_same_v<T, int>> foo(const T&) {
+ void foo(const T&) {