La sostituzione è eseguita su un tipo di pacchetto di parametri variadic se il pacchetto è vuoto?

Question

Si consideri il seguente programma:

#include <type_traits> 

enum class dummy {}; 
template <typename T> 
using EnableIf = typename std::enable_if<T::value, dummy>::type; 
template <typename T> 
using DisableIf = typename std::enable_if<!T::value, dummy>::type; 

template <typename T> 
struct dependent_true_type : std::true_type {}; 

template <typename T, 
      EnableIf<dependent_true_type<T>>...> 
std::true_type f(); 
template <typename T, 
      DisableIf<dependent_true_type<T>>...> 
std::false_type f(); 

static_assert(decltype(f<int>())::value, ""); 

int main() {} 

GCC 4.7 Glady accetta questo programma. Il mio recente clang 3.1 build afferma che la chiamata a f è ambigua.

test.c++:22:24: fatal error: call to 'f' is ambiguous 
static_assert(decltype(f<int>())::value, ""); 
         ^~~~~~ 
test.c++:17:16: note: candidate function [with T = int, $1 = <>] 
std::true_type f(); 
      ^
test.c++:20:17: note: candidate function [with T = int, $1 = <>] 
std::false_type f(); 
       ^
1 error generated. 

Lo fa accettare il programma se scrivo f<int, dummy{}>().

Sembra clang non considera il tipo del pacchetto di parametri quando il pacchetto è vuoto, il che porta a non rimuoverlo dal set candidato. GCC sembra eseguire la sostituzione sul tipo di pacchetto di parametri anche se il pacchetto è vuoto e poiché detta sostituzione non riesce per un sovraccarico, non vi è alcuna ambiguità.

Quale delle due è corretta?

Answer 1

Credo di aver trovato il pezzo rilevante di standardese. §14.8.2p7 dice:

La sostituzione avviene in tutti i tipi ed espressioni utilizzati nel tipo di funzione e nelle dichiarazioni dei parametri del modello.

Da EnableIf<dependent_true_type<T>> viene utilizzato in una dichiarazione di parametro template, dovrebbe verificarsi sostituzione e questo è a bug in clang.