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 
main()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