1 // RUN: %clang_cc1 -verify -std=c++11 %s 2 3 namespace RedeclAliasTypedef { 4 template<typename U> using T = int; 5 template<typename U> using T = int; 6 template<typename U> using T = T<U>; 7 } 8 9 namespace IllegalTypeIds { 10 template<typename U> using A = void(int n = 0); // expected-error {{default arguments can only be specified for parameters in a function declaration}} 11 template<typename U> using B = inline void(int n); // expected-error {{type name does not allow function specifier}} 12 template<typename U> using C = virtual void(int n); // expected-error {{type name does not allow function specifier}} 13 template<typename U> using D = explicit void(int n); // expected-error {{type name does not allow function specifier}} 14 template<typename U> using E = void(int n) throw(); // expected-error {{exception specifications are not allowed in type aliases}} 15 template<typename U> using F = void(*)(int n) &&; // expected-error {{pointer to function type cannot have '&&' qualifier}} 16 template<typename U> using G = __thread void(int n); // expected-error {{type name does not allow storage class to be specified}} 17 template<typename U> using H = constexpr int; // expected-error {{type name does not allow constexpr specifier}} 18 19 template<typename U> using Y = void(int n); // ok 20 template<typename U> using Z = void(int n) &&; // ok 21 } 22 23 namespace IllegalSyntax { 24 template<typename Z> using ::T = void(int n); // expected-error {{name defined in alias declaration must be an identifier}} 25 template<typename Z> using operator int = void(int n); // expected-error {{name defined in alias declaration must be an identifier}} 26 template<typename Z> using typename U = void; // expected-error {{name defined in alias declaration must be an identifier}} 27 template<typename Z> using typename ::V = void(int n); // expected-error {{name defined in alias declaration must be an identifier}} 28 template<typename Z> using typename ::operator bool = void(int n); // expected-error {{name defined in alias declaration must be an identifier}} 29 } 30 31 namespace VariableLengthArrays { 32 template<typename Z> using T = int[42]; // ok 33 34 int n = 32; 35 template<typename Z> using T = int[n]; // expected-error {{variable length array declaration not allowed at file scope}} 36 37 const int m = 42; 38 template<typename Z> using U = int[m]; // expected-note {{previous definition}} 39 template<typename Z> using U = int[42]; // ok 40 template<typename Z> using U = int; // expected-error {{type alias template redefinition with different types ('int' vs 'int [42]')}} 41 } 42 43 namespace RedeclFunc { 44 int f(int, char**); 45 template<typename Z> using T = int; 46 T<char> f(int, char **); // ok 47 } 48 49 namespace LookupFilter { 50 namespace N { template<typename U> using S = int; } 51 using namespace N; 52 template<typename U> using S = S<U>*; // ok 53 } 54 55 namespace InFunctions { 56 template<typename...T> struct S0 { 57 template<typename Z> using U = T*; // expected-error {{declaration type contains unexpanded parameter pack 'T'}} 58 U<char> u; 59 }; 60 61 template<typename Z> using T1 = int; 62 template<typename Z> using T2 = int[-1]; // expected-error {{array size is negative}} 63 template<typename...T> struct S3 { // expected-note {{template parameter is declared here}} 64 template<typename Z> using T = int; // expected-error {{declaration of 'T' shadows template parameter}} 65 }; 66 template<typename Z> using Z = Z; 67 } 68 69 namespace ClassNameRedecl { 70 class C0 { 71 template<typename U> using C0 = int; // expected-error {{member 'C0' has the same name as its class}} 72 }; 73 class C1 { 74 template<typename U> using C1 = C1; // expected-error {{member 'C1' has the same name as its class}} 75 }; 76 class C2 { 77 template<typename U> using C0 = C1; // ok 78 }; 79 template<typename...T> class C3 { 80 template<typename U> using f = T; // expected-error {{declaration type contains unexpanded parameter pack 'T'}} 81 }; 82 template<typename T> class C4 { // expected-note {{template parameter is declared here}} 83 template<typename U> using T = int; // expected-error {{declaration of 'T' shadows template parameter}} 84 }; 85 class C5 { 86 class c; // expected-note {{previous definition}} 87 template<typename U> using c = int; // expected-error {{redefinition of 'c' as different kind of symbol}} 88 class d; // expected-note {{previous definition}} 89 template<typename U> using d = d; // expected-error {{redefinition of 'd' as different kind of symbol}} 90 }; 91 class C6 { 92 class c { template<typename U> using C6 = int; }; // ok 93 }; 94 } 95 96 class CtorDtorName { 97 template<typename T> using X = CtorDtorName; 98 X<int>(); // expected-error {{expected member name}} 99 ~X<int>(); // expected-error {{destructor cannot be declared using a type alias}} 100 }; 101 102 namespace TagName { 103 template<typename Z> using S = struct { int n; }; // expected-error {{cannot be defined}} 104 template<typename Z> using T = class { int n; }; // expected-error {{cannot be defined}} 105 template<typename Z> using U = enum { a, b, c }; // expected-error {{cannot be defined}} 106 template<typename Z> using V = struct V { int n; }; // expected-error {{'TagName::V' cannot be defined in a type alias template}} 107 } 108 109 namespace StdExample { 110 template<typename T, typename U> struct pair; 111 112 template<typename T> using handler_t = void (*)(T); 113 extern handler_t<int> ignore; 114 extern void (*ignore)(int); 115 // FIXME: we recover as if cell is an undeclared variable. the diagnostics are terrible! 116 template<typename T> using cell = pair<T*, cell<T>*>; // expected-error {{use of undeclared identifier 'cell'}} \ 117 expected-error {{'T' does not refer to a value}} \ 118 expected-note {{declared here}} \ 119 expected-error {{expected ';' after alias declaration}} 120 } 121 122 namespace Access { 123 class C0 { 124 template<typename Z> using U = int; // expected-note {{declared private here}} 125 }; 126 C0::U<int> v; // expected-error {{'U' is a private member}} 127 class C1 { 128 public: 129 template<typename Z> using U = int; 130 }; 131 C1::U<int> w; // ok 132 } 133 134 namespace VoidArg { 135 template<typename Z> using V = void; 136 V<int> f(int); // ok 137 V<char> g(V<double>); // ok (DR577) 138 } 139 140 namespace Curried { 141 template<typename T, typename U> struct S; 142 template<typename T> template<typename U> using SS = S<T, U>; // expected-error {{extraneous template parameter list in alias template declaration}} 143 } 144 145 // PR12647 146 namespace SFINAE { 147 template<bool> struct enable_if; // expected-note 2{{here}} 148 template<> struct enable_if<true> { using type = void; }; 149 150 template<typename T> struct is_enum { static constexpr bool value = __is_enum(T); }; 151 152 template<typename T> using EnableIf = typename enable_if<T::value>::type; // expected-error {{undefined template}} 153 template<typename T> using DisableIf = typename enable_if<!T::value>::type; // expected-error {{undefined template}} 154 155 template<typename T> EnableIf<is_enum<T>> f(); 156 template<typename T> DisableIf<is_enum<T>> f(); 157 158 enum E { e }; 159 160 int main() { 161 f<int>(); 162 f<E>(); 163 } 164 165 template<typename T, typename U = EnableIf<is_enum<T>>> struct fail1 {}; // expected-note {{here}} 166 template<typename T> struct fail2 : DisableIf<is_enum<T>> {}; // expected-note {{here}} 167 168 fail1<int> f1; // expected-note {{here}} 169 fail2<E> f2; // expected-note {{here}} 170 } 171 172 namespace PR24212 { 173 struct X {}; 174 template <int I> 175 struct S { 176 template <int J> 177 using T = X[J]; 178 using U = T<I>; 179 }; 180 static_assert(__is_same(S<3>::U, X[2]), ""); // expected-error {{static_assert failed}} 181 } 182
