Può l'ereditarietà dei template dalla sua un'altra specializzazione essere una dipendenza circolare o è bug di un clangore

Question

Considerare codice qui sotto:

#include <iostream> 
#include <utility> 
#include <tuple> 

template <class TargetIndices, class SourceIndices> 
struct assign; 

template <size_t... TargetIs, size_t... SourceIs> 
struct assign<std::index_sequence<TargetIs...>, std::index_sequence<SourceIs...>>: assign<std::index_sequence<TargetIs>, std::index_sequence<SourceIs>>... { 
    template <class TargetTuple, class SourceTuple> 
    assign(TargetTuple &target, const SourceTuple &source): assign<std::index_sequence<TargetIs>, std::index_sequence<SourceIs>>(target, source)... { } 
}; 

template <size_t FirstTI, size_t FirstSI> 
struct assign<std::index_sequence<FirstTI>, std::index_sequence<FirstSI>> { 
    template <class TargetTuple, class SourceTuple> 
    assign(TargetTuple &target, const SourceTuple &source) { 
     std::get<FirstTI>(target) = std::get<FirstSI>(source); 
    } 
}; 


int main() { 
    std::tuple<int, int, int> t1 = std::make_tuple(0,0,0), t2 = std::make_tuple(1,2,3); 
    assign<std::index_sequence<0,2>, std::index_sequence<2,0>>(t1, t2); 
    std::cout << std::get<0>(t1) << " " << std::get<1>(t1) << " " << std::get<2>(t1) << std::endl; 
} 

clang ++ afferma che c'è una dipendenza circolare in eredità. g ++ lo compila senza problemi. Quale compilatore ha ragione?

Answer 1

Sembra un bug di clang.

Una riproduzione minimo simile a questa:

template <int...> struct q {}; 

template <int... Is> using w = q<Is...>; 

template <class T> 
struct a; 

template <int F> 
struct a<w<F>> {}; 

template <int... T> 
struct a<w<T...>>: a<w<T>>... {}; // g++ OK, clang++ breaks 

L'alias modello è essenziale qui. Quando il modello originale viene utilizzato nell'ultima riga invece dell'alias modello, viene compilato:

struct a<q<T...>>: a<q<T>>... {}; // g++, clang++ OK