1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 2 3 // This test concerns the identity of dependent types within the 4 // canonical type system. This corresponds to C++ [temp.type], which 5 // specifies type equivalence within a template. 6 // 7 // FIXME: template template parameters 8 9 namespace N { 10 template<typename T> 11 struct X2 { 12 template<typename U> 13 struct apply { 14 typedef U* type; 15 }; 16 }; 17 } 18 19 namespace Nalias = N; 20 21 template<typename T> 22 struct X0 { }; 23 24 using namespace N; 25 26 template<typename T, typename U> 27 struct X1 { 28 typedef T type; 29 typedef U U_type; 30 31 void f0(T); // expected-note{{previous}} 32 void f0(U); 33 void f0(type); // expected-error{{redeclar}} 34 35 void f1(T*); // expected-note{{previous}} 36 void f1(U*); 37 void f1(type*); // expected-error{{redeclar}} 38 39 void f2(X0<T>*); // expected-note{{previous}} 40 void f2(X0<U>*); 41 void f2(X0<type>*); // expected-error{{redeclar}} 42 43 void f3(X0<T>*); // expected-note{{previous}} 44 void f3(X0<U>*); 45 void f3(::X0<type>*); // expected-error{{redeclar}} 46 47 void f4(typename T::template apply<U>*); // expected-note{{previous}} 48 void f4(typename U::template apply<U>*); 49 void f4(typename type::template apply<T>*); 50 void f4(typename type::template apply<U_type>*); // expected-error{{redeclar}} 51 52 void f5(typename T::template apply<U>::type*); // expected-note{{previous}} 53 void f5(typename U::template apply<U>::type*); 54 void f5(typename U::template apply<T>::type*); 55 void f5(typename type::template apply<T>::type*); 56 void f5(typename type::template apply<U_type>::type*); // expected-error{{redeclar}} 57 58 void f6(typename N::X2<T>::template apply<U> *); // expected-note{{previous}} 59 void f6(typename N::X2<U>::template apply<U> *); 60 void f6(typename N::X2<U>::template apply<T> *); 61 void f6(typename ::N::X2<type>::template apply<U_type> *); // expected-error{{redeclar}} 62 63 void f7(typename N::X2<T>::template apply<U> *); // expected-note{{previous}} 64 void f7(typename N::X2<U>::template apply<U> *); 65 void f7(typename N::X2<U>::template apply<T> *); 66 void f7(typename X2<type>::template apply<U_type> *); // expected-error{{redeclar}} 67 68 void f8(typename N::X2<T>::template apply<U> *); // expected-note{{previous}} 69 void f8(typename N::X2<U>::template apply<U> *); 70 void f8(typename N::X2<U>::template apply<T> *); 71 void f8(typename ::Nalias::X2<type>::template apply<U_type> *); // expected-error{{redeclar}} 72 }; 73 74 namespace PR6851 { 75 template <bool v> 76 struct S; 77 78 struct N { 79 template <bool w> 80 S< S<w>::cond && 1 > foo(); 81 }; 82 83 struct Arrow { Arrow *operator->(); int n; }; 84 template<typename T> struct M { 85 Arrow a; 86 auto f() -> M<decltype(a->n)>; 87 }; 88 89 struct Alien; 90 bool operator&&(const Alien&, const Alien&); 91 92 template <bool w> foo()93 S< S<w>::cond && 1 > N::foo() { } 94 95 template<typename T> f()96 auto M<T>::f() -> M<decltype(a->n)> {} 97 } 98 99 namespace PR7460 { 100 template <typename T> 101 struct TemplateClass2 102 { 103 enum { SIZE = 100 }; 104 static T member[SIZE]; 105 }; 106 107 template <typename T> 108 T TemplateClass2<T>::member[TemplateClass2<T>::SIZE]; 109 } 110 111 namespace PR18275 { 112 template<typename T> struct A { 113 void f(const int); 114 void g(int); 115 void h(const T); 116 void i(T); 117 }; 118 119 template<typename T> f(int x)120 void A<T>::f(int x) { x = 0; } 121 122 template<typename T> g(const int x)123 void A<T>::g(const int x) { // expected-note {{declared const here}} 124 x = 0; // expected-error {{cannot assign to variable 'x'}} 125 } 126 127 template<typename T> h(T)128 void A<T>::h(T) {} // FIXME: Should reject this. Type is different from prior decl if T is an array type. 129 130 template<typename T> i(const T)131 void A<T>::i(const T) {} // FIXME: Should reject this. Type is different from prior decl if T is an array type. 132 133 template struct A<int>; 134 template struct A<int[1]>; 135 } 136 137 namespace PR21289 { 138 template<typename T> using X = int; 139 template<typename T, decltype(sizeof(0))> using Y = int; 140 template<typename ...Ts> struct S {}; f()141 template<typename ...Ts> void f() { 142 // This is a dependent type. It is *not* S<int>, even though it canonically 143 // contains no template parameters. 144 using Type = S<X<Ts>...>; 145 Type s; 146 using Type = S<int, int, int>; 147 } g()148 void g() { f<void, void, void>(); } 149 h(S<int>)150 template<typename ...Ts> void h(S<int>) {} 151 // Pending a core issue, it's not clear if these are redeclarations, but they 152 // are probably intended to be... even though substitution can succeed for one 153 // of them but fail for the other! h(S<X<Ts>...>)154 template<typename ...Ts> void h(S<X<Ts>...>) {} // expected-note {{previous}} h(S<Y<Ts,sizeof (Ts)>...>)155 template<typename ...Ts> void h(S<Y<Ts, sizeof(Ts)>...>) {} // expected-error {{redefinition}} 156 } 157