1 // RUN: %clang_cc1 -std=gnu++11 -fsyntax-only -verify %s
2 // RUN: not %clang_cc1 -std=gnu++11 -ast-dump %s | FileCheck %s
3 
4 namespace attribute_aligned {
5   template<int N>
6   struct X {
7     char c[1] __attribute__((__aligned__((N)))); // expected-error {{alignment is not a power of 2}}
8   };
9 
10   template <bool X> struct check {
11     int check_failed[X ? 1 : -1]; // expected-error {{array with a negative size}}
12   };
13 
14   template <int N> struct check_alignment {
15     typedef check<N == sizeof(X<N>)> t; // expected-note {{in instantiation}}
16   };
17 
18   check_alignment<1>::t c1;
19   check_alignment<2>::t c2;
20   check_alignment<3>::t c3; // expected-note 2 {{in instantiation}}
21   check_alignment<4>::t c4;
22 
23   template<unsigned Size, unsigned Align>
24   class my_aligned_storage
25   {
26     __attribute__((aligned(Align))) char storage[Size];
27   };
28 
29   template<typename T>
30   class C {
31   public:
32     C() {
33       static_assert(sizeof(t) == sizeof(T), "my_aligned_storage size wrong");
34       static_assert(alignof(t) == alignof(T), "my_aligned_storage align wrong"); // expected-warning{{'alignof' applied to an expression is a GNU extension}}
35     }
36 
37   private:
38     my_aligned_storage<sizeof(T), alignof(T)> t;
39   };
40 
41   C<double> cd;
42 }
43 
44 namespace PR9049 {
45   extern const void *CFRetain(const void *ref);
46 
47   template<typename T> __attribute__((cf_returns_retained))
48   inline T WBCFRetain(T aValue) { return aValue ? (T)CFRetain(aValue) : (T)0; }
49 
50 
51   extern void CFRelease(const void *ref);
52 
53   template<typename T>
54   inline void WBCFRelease(__attribute__((cf_consumed)) T aValue) { if(aValue) CFRelease(aValue); }
55 }
56 
57 namespace attribute_annotate {
58 // CHECK: FunctionTemplateDecl {{.*}} HasAnnotations
59 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_FOO"
60 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_BAR"
61 // CHECK: FunctionDecl {{.*}} HasAnnotations
62 // CHECK:   TemplateArgument type 'int'
63 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_FOO"
64 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_BAR"
65 template<typename T> [[clang::annotate("ANNOTATE_FOO"), clang::annotate("ANNOTATE_BAR")]] void HasAnnotations();
66 void UseAnnotations() { HasAnnotations<int>(); }
67 
68 // CHECK:      FunctionTemplateDecl {{.*}} HasPackAnnotations
69 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
70 // CHECK-NEXT:   FunctionDecl {{.*}} HasPackAnnotations 'void ()'
71 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BAZ"
72 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
73 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
74 // CHECK-NEXT:   FunctionDecl {{.*}} used HasPackAnnotations 'void ()'
75 // CHECK-NEXT:     TemplateArgument{{.*}} pack
76 // CHECK-NEXT:       TemplateArgument{{.*}} integral 1
77 // CHECK-NEXT:       TemplateArgument{{.*}} integral 2
78 // CHECK-NEXT:       TemplateArgument{{.*}} integral 3
79 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BAZ"
80 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
81 // CHECK-NEXT:         value: Int 1
82 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
83 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
84 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 1
85 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
86 // CHECK-NEXT:         value: Int 2
87 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
88 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
89 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 2
90 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
91 // CHECK-NEXT:         value: Int 3
92 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
93 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
94 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 3
95 template <int... Is> [[clang::annotate("ANNOTATE_BAZ", Is...)]] void HasPackAnnotations();
96 void UsePackAnnotations() { HasPackAnnotations<1, 2, 3>(); }
97 
98 template <int... Is> [[clang::annotate(Is...)]] void HasOnlyPackAnnotation() {} // expected-error {{'annotate' attribute takes at least 1 argument}} expected-error {{'annotate' attribute requires a string}}
99 
100 void UseOnlyPackAnnotations() {
101   HasOnlyPackAnnotation<>();  // expected-note {{in instantiation of function template specialization 'attribute_annotate::HasOnlyPackAnnotation<>' requested here}}
102   HasOnlyPackAnnotation<1>(); // expected-note {{in instantiation of function template specialization 'attribute_annotate::HasOnlyPackAnnotation<1>' requested here}}
103 }
104 
105 // CHECK:      ClassTemplateDecl {{.*}} AnnotatedPackTemplateStruct
106 // CHECK-NEXT:   TemplateTypeParmDecl {{.*}} typename depth 0 index 0 T
107 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
108 // CHECK-NEXT:   CXXRecordDecl {{.*}} struct AnnotatedPackTemplateStruct definition
109 // CHECK-NEXT:     DefinitionData
110 // CHECK-NEXT:       DefaultConstructor
111 // CHECK-NEXT:       CopyConstructor
112 // CHECK-NEXT:       MoveConstructor
113 // CHECK-NEXT:       CopyAssignment
114 // CHECK-NEXT:       MoveAssignment
115 // CHECK-NEXT:       Destructor
116 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FOZ"
117 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
118 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
119 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
120 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
121 // CHECK-NEXT:     DefinitionData
122 // CHECK-NEXT:       DefaultConstructor
123 // CHECK-NEXT:       CopyConstructor
124 // CHECK-NEXT:       MoveConstructor
125 // CHECK-NEXT:       CopyAssignment
126 // CHECK-NEXT:       MoveAssignment
127 // CHECK-NEXT:       Destructor
128 // CHECK-NEXT:     TemplateArgument{{.*}} type 'int'
129 // CHECK-NEXT:       BuiltinType {{.*}} 'int'
130 // CHECK-NEXT:     TemplateArgument{{.*}} pack
131 // CHECK-NEXT:       TemplateArgument{{.*}} integral 1
132 // CHECK-NEXT:       TemplateArgument{{.*}} integral 2
133 // CHECK-NEXT:       TemplateArgument{{.*}} integral 3
134 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BOO"
135 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
136 // CHECK-NEXT:         value: Int 1
137 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
138 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
139 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 1
140 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
141 // CHECK-NEXT:         value: Int 2
142 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
143 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
144 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 2
145 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
146 // CHECK-NEXT:         value: Int 3
147 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
148 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
149 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 3
150 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
151 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
152 // CHECK-NEXT:     DefinitionData
153 // CHECK-NEXT:       DefaultConstructor
154 // CHECK-NEXT:       CopyConstructor
155 // CHECK-NEXT:       MoveConstructor
156 // CHECK-NEXT:       CopyAssignment
157 // CHECK-NEXT:       MoveAssignment
158 // CHECK-NEXT:       Destructor
159 // CHECK-NEXT:     TemplateArgument type 'float'
160 // CHECK-NEXT:       BuiltinType {{.*}} 'float'
161 // CHECK-NEXT:     TemplateArgument{{.*}} pack
162 // CHECK-NEXT:       TemplateArgument{{.*}} integral 3
163 // CHECK-NEXT:       TemplateArgument{{.*}} integral 2
164 // CHECK-NEXT:       TemplateArgument{{.*}} integral 1
165 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FOZ"
166 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
167 // CHECK-NEXT:         value: Int 4
168 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 4
169 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
170 // CHECK-NEXT:         value: Int 5
171 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 5
172 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
173 // CHECK-NEXT:         value: Int 6
174 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 6
175 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
176 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
177 // CHECK-NEXT:     DefinitionData
178 // CHECK-NEXT:       DefaultConstructor
179 // CHECK-NEXT:       CopyConstructor
180 // CHECK-NEXT:       MoveConstructor
181 // CHECK-NEXT:       CopyAssignment
182 // CHECK-NEXT:       MoveAssignment
183 // CHECK-NEXT:       Destructor
184 // CHECK-NEXT:     TemplateArgument type 'bool'
185 // CHECK-NEXT:       BuiltinType {{.*}} 'bool'
186 // CHECK-NEXT:     TemplateArgument{{.*}} pack
187 // CHECK-NEXT:       TemplateArgument{{.*}} integral 7
188 // CHECK-NEXT:       TemplateArgument{{.*}} integral 8
189 // CHECK-NEXT:       TemplateArgument{{.*}} integral 9
190 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FOZ"
191 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
192 // CHECK-NEXT:         value: Int 7
193 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
194 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
195 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 7
196 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
197 // CHECK-NEXT:         value: Int 8
198 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
199 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
200 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 8
201 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
202 // CHECK-NEXT:         value: Int 9
203 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
204 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
205 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 9
206 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
207 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
208 // CHECK-NEXT:     DefinitionData
209 // CHECK-NEXT:       DefaultConstructor
210 // CHECK-NEXT:       CopyConstructor
211 // CHECK-NEXT:       MoveConstructor
212 // CHECK-NEXT:       CopyAssignment
213 // CHECK-NEXT:       MoveAssignment
214 // CHECK-NEXT:       Destructor
215 // CHECK-NEXT:     TemplateArgument type 'char'
216 // CHECK-NEXT:       BuiltinType {{.*}} 'char'
217 // CHECK-NEXT:     TemplateArgument{{.*}} pack
218 // CHECK-NEXT:       TemplateArgument{{.*}} integral 1
219 // CHECK-NEXT:       TemplateArgument{{.*}} integral 2
220 // CHECK-NEXT:       TemplateArgument{{.*}} integral 3
221 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
222 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
223 // CHECK-NEXT:     DefinitionData
224 // CHECK-NEXT:       DefaultConstructor
225 // CHECK-NEXT:       CopyConstructor
226 // CHECK-NEXT:       MoveConstructor
227 // CHECK-NEXT:       CopyAssignment
228 // CHECK-NEXT:       MoveAssignment
229 // CHECK-NEXT:       Destructor
230 // CHECK-NEXT:     TemplateArgument{{.*}} type 'char'
231 // CHECK-NEXT:       BuiltinType {{.*}} 'char'
232 // CHECK-NEXT:     TemplateArgument{{.*}} pack
233 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
234 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
235 // CHECK-NEXT:   DefinitionData
236 // CHECK-NEXT:     DefaultConstructor
237 // CHECK-NEXT:     CopyConstructor
238 // CHECK-NEXT:     MoveConstructor
239 // CHECK-NEXT:     CopyAssignment
240 // CHECK-NEXT:     MoveAssignment
241 // CHECK-NEXT:     Destructor
242 // CHECK-NEXT:   TemplateArgument{{.*}} type 'int'
243 // CHECK-NEXT:     BuiltinType {{.*}} 'int'
244 // CHECK-NEXT:   TemplateArgument{{.*}} pack
245 // CHECK-NEXT:     TemplateArgument{{.*}} expr
246 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
247 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
248 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
249 // CHECK-NEXT:   AnnotateAttr {{.*}} "ANNOTATE_BOO"
250 // CHECK-NEXT:     PackExpansionExpr {{.*}} '<dependent type>'
251 // CHECK-NEXT:       DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
252 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
253 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
254 // CHECK-NEXT:   DefinitionData
255 // CHECK-NEXT:     DefaultConstructor
256 // CHECK-NEXT:     CopyConstructor
257 // CHECK-NEXT:     MoveConstructor
258 // CHECK-NEXT:     CopyAssignment
259 // CHECK-NEXT:     MoveAssignment
260 // CHECK-NEXT:     Destructor
261 // CHECK-NEXT:   TemplateArgument{{.*}} type 'float'
262 // CHECK-NEXT:     BuiltinType {{.*}} 'float'
263 // CHECK-NEXT:   TemplateArgument{{.*}} pack
264 // CHECK-NEXT:     TemplateArgument{{.*}} expr
265 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
266 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
267 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
268 // CHECK-NEXT:   AnnotateAttr {{.*}} "ANNOTATE_FOZ"
269 // CHECK-NEXT:     ConstantExpr {{.*}} 'int'
270 // CHECK-NEXT:       value: Int 4
271 // CHECK-NEXT:       IntegerLiteral {{.*}} 'int' 4
272 // CHECK-NEXT:     ConstantExpr {{.*}} 'int'
273 // CHECK-NEXT:       value: Int 5
274 // CHECK-NEXT:       IntegerLiteral {{.*}} 'int' 5
275 // CHECK-NEXT:     ConstantExpr {{.*}} 'int'
276 // CHECK-NEXT:       value: Int 6
277 // CHECK-NEXT:       IntegerLiteral {{.*}} 'int' 6
278 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
279 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct AnnotatedPackTemplateStruct definition
280 // CHECK-NEXT:   DefinitionData
281 // CHECK-NEXT:     DefaultConstructor
282 // CHECK-NEXT:     CopyConstructor
283 // CHECK-NEXT:     MoveConstructor
284 // CHECK-NEXT:     CopyAssignment
285 // CHECK-NEXT:     MoveAssignment
286 // CHECK-NEXT:     Destructor
287 // CHECK-NEXT:   TemplateArgument{{.*}} type 'char'
288 // CHECK-NEXT:     BuiltinType {{.*}} 'char'
289 // CHECK-NEXT:   TemplateArgument{{.*}} pack
290 // CHECK-NEXT:     TemplateArgument{{.*}} expr
291 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
292 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
293 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
294 // CHECK-NEXT:   AnnotateAttr {{.*}} ""
295 // CHECK-NEXT:     PackExpansionExpr {{.*}} '<dependent type>'
296 // CHECK-NEXT:       DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
297 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct AnnotatedPackTemplateStruct
298 template <typename T, int... Is> struct [[clang::annotate("ANNOTATE_FOZ", Is...)]] AnnotatedPackTemplateStruct{};
299 template <int... Is> struct [[clang::annotate("ANNOTATE_BOO", Is...)]] AnnotatedPackTemplateStruct<int, Is...>{};
300 template <int... Is> struct [[clang::annotate("ANNOTATE_FOZ", 4, 5, 6)]] AnnotatedPackTemplateStruct<float, Is...>{};
301 template <int... Is> struct [[clang::annotate(Is...)]] AnnotatedPackTemplateStruct<char, Is...>{}; // expected-error {{'annotate' attribute requires a string}} expected-error {{'annotate' attribute takes at least 1 argument}}
302 void UseAnnotatedPackTemplateStructSpecializations() {
303   AnnotatedPackTemplateStruct<int, 1, 2, 3> Instance1{};
304   AnnotatedPackTemplateStruct<float, 3, 2, 1> Instance2{};
305   AnnotatedPackTemplateStruct<bool, 7, 8, 9> Instance3{};
306   AnnotatedPackTemplateStruct<char, 1, 2, 3> Instance4{}; // expected-note {{in instantiation of template class 'attribute_annotate::AnnotatedPackTemplateStruct<char, 1, 2, 3>' requested here}}
307   AnnotatedPackTemplateStruct<char> Instance5{};          // expected-note {{in instantiation of template class 'attribute_annotate::AnnotatedPackTemplateStruct<char>' requested here}}
308 }
309 
310 // CHECK:      ClassTemplateDecl {{.*}} InvalidAnnotatedPackTemplateStruct
311 // CHECK-NEXT:   TemplateTypeParmDecl {{.*}} typename depth 0 index 0 T
312 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 1 ... Is
313 // CHECK-NEXT:   CXXRecordDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
314 // CHECK-NEXT:     DefinitionData
315 // CHECK-NEXT:       DefaultConstructor
316 // CHECK-NEXT:       CopyConstructor
317 // CHECK-NEXT:       MoveConstructor
318 // CHECK-NEXT:       CopyAssignment
319 // CHECK-NEXT:       MoveAssignment
320 // CHECK-NEXT:       Destructor
321 // CHECK-NEXT:     AnnotateAttr {{.*}} ""
322 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
323 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
324 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
325 // CHECK-NEXT:   ClassTemplateSpecialization {{.*}} 'InvalidAnnotatedPackTemplateStruct'
326 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
327 // CHECK-NEXT:     DefinitionData
328 // CHECK-NEXT:       DefaultConstructor
329 // CHECK-NEXT:       CopyConstructor
330 // CHECK-NEXT:       MoveConstructor
331 // CHECK-NEXT:       CopyAssignment
332 // CHECK-NEXT:       MoveAssignment
333 // CHECK-NEXT:       Destructor
334 // CHECK-NEXT:     TemplateArgument{{.*}} type 'int'
335 // CHECK-NEXT:       BuiltinType {{.*}} 'int'
336 // CHECK-NEXT:     TemplateArgument{{.*}} pack
337 // CHECK-NEXT:       TemplateArgument{{.*}} integral 1
338 // CHECK-NEXT:       TemplateArgument{{.*}} integral 2
339 // CHECK-NEXT:       TemplateArgument{{.*}} integral 3
340 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BIR"
341 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
342 // CHECK-NEXT:         value: Int 1
343 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
344 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
345 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 1
346 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
347 // CHECK-NEXT:         value: Int 2
348 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
349 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
350 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 2
351 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
352 // CHECK-NEXT:         value: Int 3
353 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
354 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
355 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 3
356 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
357 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
358 // CHECK-NEXT:     DefinitionData
359 // CHECK-NEXT:       DefaultConstructor
360 // CHECK-NEXT:       CopyConstructor
361 // CHECK-NEXT:       MoveConstructor
362 // CHECK-NEXT:       CopyAssignment
363 // CHECK-NEXT:       MoveAssignment
364 // CHECK-NEXT:       Destructor
365 // CHECK-NEXT:     TemplateArgument{{.*}} type 'float'
366 // CHECK-NEXT:       BuiltinType {{.*}} 'float'
367 // CHECK-NEXT:     TemplateArgument{{.*}} pack
368 // CHECK-NEXT:       TemplateArgument{{.*}} integral 3
369 // CHECK-NEXT:       TemplateArgument{{.*}} integral 2
370 // CHECK-NEXT:       TemplateArgument{{.*}} integral 1
371 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
372 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
373 // CHECK-NEXT:     DefinitionData
374 // CHECK-NEXT:       DefaultConstructor
375 // CHECK-NEXT:       CopyConstructor
376 // CHECK-NEXT:       MoveConstructor
377 // CHECK-NEXT:       CopyAssignment
378 // CHECK-NEXT:       MoveAssignment
379 // CHECK-NEXT:       Destructor
380 // CHECK-NEXT:     TemplateArgument{{.*}} type 'bool'
381 // CHECK-NEXT:       BuiltinType {{.*}} 'bool'
382 // CHECK-NEXT:     TemplateArgument{{.*}} pack
383 // CHECK-NEXT:       TemplateArgument{{.*}} integral 7
384 // CHECK-NEXT:       TemplateArgument{{.*}} integral 8
385 // CHECK-NEXT:       TemplateArgument{{.*}} integral 9
386 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
387 // CHECK-NEXT:   ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
388 // CHECK-NEXT:     DefinitionData
389 // CHECK-NEXT:       DefaultConstructor
390 // CHECK-NEXT:       CopyConstructor
391 // CHECK-NEXT:       MoveConstructor
392 // CHECK-NEXT:       CopyAssignment
393 // CHECK-NEXT:       MoveAssignment
394 // CHECK-NEXT:       Destructor
395 // CHECK-NEXT:     TemplateArgument{{.*}} type 'bool'
396 // CHECK-NEXT:       BuiltinType {{.*}} 'bool'
397 // CHECK-NEXT:     TemplateArgument{{.*}} pack
398 // CHECK-NEXT:     CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
399 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
400 // CHECK-NEXT:   DefinitionData
401 // CHECK-NEXT:     DefaultConstructor
402 // CHECK-NEXT:     CopyConstructor
403 // CHECK-NEXT:     MoveConstructor
404 // CHECK-NEXT:     CopyAssignment
405 // CHECK-NEXT:     MoveAssignment
406 // CHECK-NEXT:     Destructor
407 // CHECK-NEXT:   TemplateArgument{{.*}} type 'int'
408 // CHECK-NEXT:     BuiltinType {{.*}} 'int'
409 // CHECK-NEXT:   TemplateArgument{{.*}} pack
410 // CHECK-NEXT:     TemplateArgument{{.*}} expr
411 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
412 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
413 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
414 // CHECK-NEXT:   AnnotateAttr {{.*}} "ANNOTATE_BIR"
415 // CHECK-NEXT:     PackExpansionExpr {{.*}} '<dependent type>'
416 // CHECK-NEXT:       DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
417 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
418 // CHECK-NEXT: ClassTemplatePartialSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
419 // CHECK-NEXT:   DefinitionData
420 // CHECK-NEXT:     DefaultConstructor
421 // CHECK-NEXT:     CopyConstructor
422 // CHECK-NEXT:     MoveConstructor
423 // CHECK-NEXT:     CopyAssignment
424 // CHECK-NEXT:     MoveAssignment
425 // CHECK-NEXT:     Destructor
426 // CHECK-NEXT:   TemplateArgument{{.*}} type 'float'
427 // CHECK-NEXT:     BuiltinType {{.*}} 'float'
428 // CHECK-NEXT:   TemplateArgument{{.*}} pack
429 // CHECK-NEXT:     TemplateArgument{{.*}} expr
430 // CHECK-NEXT:       PackExpansionExpr {{.*}} 'int'
431 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
432 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
433 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
434 // CHECK-NEXT: ClassTemplateSpecializationDecl {{.*}} struct InvalidAnnotatedPackTemplateStruct definition
435 // CHECK-NEXT:   DefinitionData
436 // CHECK-NEXT:     DefaultConstructor
437 // CHECK-NEXT:     CopyConstructor
438 // CHECK-NEXT:     MoveConstructor
439 // CHECK-NEXT:     CopyAssignment
440 // CHECK-NEXT:     MoveAssignment
441 // CHECK-NEXT:     Destructor
442 // CHECK-NEXT:   TemplateArgument{{.*}} type 'char'
443 // CHECK-NEXT:     BuiltinType {{.*}} 'char'
444 // CHECK-NEXT:   TemplateArgument{{.*}} pack
445 // CHECK-NEXT:     TemplateArgument{{.*}} integral 5
446 // CHECK-NEXT:     TemplateArgument{{.*}} integral 6
447 // CHECK-NEXT:     TemplateArgument{{.*}} integral 7
448 // CHECK-NEXT:   CXXRecordDecl {{.*}} implicit struct InvalidAnnotatedPackTemplateStruct
449 template <typename T, int... Is> struct [[clang::annotate(Is...)]] InvalidAnnotatedPackTemplateStruct{}; // expected-error {{'annotate' attribute requires a string}} expected-error {{'annotate' attribute takes at least 1 argument}}
450 template <int... Is> struct [[clang::annotate("ANNOTATE_BIR", Is...)]] InvalidAnnotatedPackTemplateStruct<int, Is...>{};
451 template <int... Is> struct InvalidAnnotatedPackTemplateStruct<float, Is...> {};
452 template <> struct InvalidAnnotatedPackTemplateStruct<char, 5, 6, 7> {};
453 void UseInvalidAnnotatedPackTemplateStruct() {
454   InvalidAnnotatedPackTemplateStruct<int, 1, 2, 3> Instance1{};
455   InvalidAnnotatedPackTemplateStruct<float, 3, 2, 1> Instance2{};
456   InvalidAnnotatedPackTemplateStruct<char, 5, 6, 7> Instance3{};
457   InvalidAnnotatedPackTemplateStruct<bool, 7, 8, 9> Instance4{}; // expected-note {{in instantiation of template class 'attribute_annotate::InvalidAnnotatedPackTemplateStruct<bool, 7, 8, 9>' requested here}}
458   InvalidAnnotatedPackTemplateStruct<bool> Instance5{};          // expected-note {{in instantiation of template class 'attribute_annotate::InvalidAnnotatedPackTemplateStruct<bool>' requested here}}
459 }
460 
461 // CHECK:      FunctionTemplateDecl {{.*}} RedeclaredAnnotatedFunc
462 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
463 // CHECK-NEXT:   FunctionDecl {{.*}} RedeclaredAnnotatedFunc 'void ()'
464 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FAR"
465 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
466 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
467 // CHECK-NEXT:   FunctionDecl {{.*}} used RedeclaredAnnotatedFunc 'void ()'
468 // CHECK-NEXT:     TemplateArgument{{.*}} pack
469 // CHECK-NEXT:       TemplateArgument{{.*}} integral 1
470 // CHECK-NEXT:       TemplateArgument{{.*}} integral 2
471 // CHECK-NEXT:       TemplateArgument{{.*}} integral 3
472 // CHECK-NEXT:     CompoundStmt
473 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FAR"
474 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
475 // CHECK-NEXT:         value: Int 1
476 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
477 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
478 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 1
479 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
480 // CHECK-NEXT:         value: Int 2
481 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
482 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
483 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 2
484 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
485 // CHECK-NEXT:         value: Int 3
486 // CHECK-NEXT:         SubstNonTypeTemplateParmExpr {{.*}} 'int'
487 // CHECK-NEXT:           NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
488 // CHECK-NEXT:           IntegerLiteral {{.*}} 'int' 3
489 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FIZ"
490 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
491 // CHECK-NEXT:         value: Int 4
492 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 4
493 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
494 // CHECK-NEXT:         value: Int 5
495 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 5
496 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BOZ"
497 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
498 // CHECK-NEXT:         value: Int 6
499 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 6
500 // CHECK-NEXT: FunctionTemplateDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc
501 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is
502 // CHECK-NEXT:   FunctionDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc 'void ()'
503 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_FAR"
504 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
505 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
506 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BOZ"
507 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
508 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
509 // CHECK-NEXT:   Function {{.*}} 'RedeclaredAnnotatedFunc' 'void ()'
510 // CHECK-NEXT: FunctionTemplateDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc
511 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} 'int' depth 0 index 0 ... Is
512 // CHECK-NEXT:   FunctionDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc 'void ()'
513 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_FAR"
514 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
515 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
516 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_BOZ"
517 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
518 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
519 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_FIZ"
520 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
521 // CHECK-NEXT:         value: Int 4
522 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 4
523 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
524 // CHECK-NEXT:         value: Int 5
525 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 5
526 // CHECK-NEXT:   Function {{.*}} 'RedeclaredAnnotatedFunc' 'void ()'
527 // CHECK-NEXT: FunctionTemplateDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc
528 // CHECK-NEXT:   NonTypeTemplateParmDecl {{.*}} 'int' depth 0 index 0 ... Is
529 // CHECK-NEXT:   FunctionDecl {{.*}} prev {{.*}} RedeclaredAnnotatedFunc 'void ()'
530 // CHECK-NEXT:     CompoundStmt
531 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_FAR"
532 // CHECK-NEXT:       PackExpansionExpr {{.*}} '<dependent type>'
533 // CHECK-NEXT:         DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int'
534 // CHECK-NEXT:     AnnotateAttr {{.*}} Inherited "ANNOTATE_FIZ"
535 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
536 // CHECK-NEXT:         value: Int 4
537 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 4
538 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
539 // CHECK-NEXT:         value: Int 5
540 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 5
541 // CHECK-NEXT:     AnnotateAttr {{.*}} "ANNOTATE_BOZ"
542 // CHECK-NEXT:       ConstantExpr {{.*}} 'int'
543 // CHECK-NEXT:         value: Int 6
544 // CHECK-NEXT:         IntegerLiteral {{.*}} 'int' 6
545 // CHECK-NEXT:   Function {{.*}} 'RedeclaredAnnotatedFunc' 'void ()'
546 // CHECK-NEXT: EmptyDecl
547 template <int... Is> [[clang::annotate("ANNOTATE_FAR", Is...)]] void RedeclaredAnnotatedFunc();
548 template <int... Is> [[clang::annotate("ANNOTATE_BOZ", Is...)]] void RedeclaredAnnotatedFunc();
549 template <int... Is> [[clang::annotate("ANNOTATE_FIZ", 4, 5)]] void RedeclaredAnnotatedFunc();
550 template <int... Is> [[clang::annotate("ANNOTATE_BOZ", 6)]] void RedeclaredAnnotatedFunc(){};
551 void UseRedeclaredAnnotatedFunc() {
552   RedeclaredAnnotatedFunc<1, 2, 3>();
553 }
554 
555 } // namespace attribute_annotate
556 
557 namespace preferred_name {
558   int x [[clang::preferred_name("frank")]]; // expected-error {{expected a type}}
559   int y [[clang::preferred_name(int)]]; // expected-warning {{'preferred_name' attribute only applies to class templates}}
560   struct [[clang::preferred_name(int)]] A; // expected-warning {{'preferred_name' attribute only applies to class templates}}
561   template<typename T> struct [[clang::preferred_name(int)]] B; // expected-error {{argument 'int' to 'preferred_name' attribute is not a typedef for a specialization of 'B'}}
562   template<typename T> struct C;
563   using X = C<int>; // expected-note {{'X' declared here}}
564   typedef C<float> Y;
565   using Z = const C<double>; // expected-note {{'Z' declared here}}
566   template<typename T> struct [[clang::preferred_name(C<int>)]] C; // expected-error {{argument 'C<int>' to 'preferred_name' attribute is not a typedef for a specialization of 'C'}}
567   template<typename T> struct [[clang::preferred_name(X), clang::preferred_name(Y)]] C;
568   template<typename T> struct [[clang::preferred_name(const X)]] C; // expected-error {{argument 'const preferred_name::X'}}
569   template<typename T> struct [[clang::preferred_name(Z)]] C; // expected-error {{argument 'preferred_name::Z' (aka 'const C<double>')}}
570   template<typename T> struct C {};
571 
572   // CHECK: ClassTemplateDecl {{.*}} <line:[[@LINE-10]]:{{.*}} C
573   // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
574   // CHECK:     TemplateArgument type 'int'
575   // CHECK-NOT: PreferredNameAttr
576   // CHECK:     PreferredNameAttr {{.*}} preferred_name::X
577   // CHECK-NOT: PreferredNameAttr
578   // CHECK:     CXXRecordDecl
579   // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
580   // CHECK:     TemplateArgument type 'float'
581   // CHECK-NOT: PreferredNameAttr
582   // CHECK:     PreferredNameAttr {{.*}} preferred_name::Y
583   // CHECK-NOT: PreferredNameAttr
584   // CHECK:     CXXRecordDecl
585   // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
586   // CHECK:     TemplateArgument type 'double'
587   // CHECK-NOT: PreferredNameAttr
588   // CHECK:     CXXRecordDecl
589 
590   // Check this doesn't cause us to instantiate the same attribute multiple times.
591   C<float> *cf1;
592   C<float> *cf2;
593 
594   void f(C<int> a, C<float> b, C<double> c) {
595     auto p = a;
596     auto q = b;
597     auto r = c;
598     p.f(); // expected-error {{no member named 'f' in 'preferred_name::X'}}
599     q.f(); // expected-error {{no member named 'f' in 'preferred_name::Y'}}
600     r.f(); // expected-error {{no member named 'f' in 'preferred_name::C<double>'}}
601   }
602 
603   template<typename T> struct D;
604   using DInt = D<int>;
605   template<typename T> struct __attribute__((__preferred_name__(DInt))) D {};
606   template struct D<int>;
607   int use_dint = D<int>().get(); // expected-error {{no member named 'get' in 'preferred_name::DInt'}}
608 
609   template<typename T> struct MemberTemplate {
610     template<typename U> struct Iter;
611     using iterator = Iter<T>;
612     using const_iterator = Iter<const T>;
613     template<typename U>
614     struct [[clang::preferred_name(iterator),
615              clang::preferred_name(const_iterator)]] Iter {};
616   };
617   template<typename T> T desugar(T);
618   auto it = desugar(MemberTemplate<int>::Iter<const int>());
619   int n = it; // expected-error {{no viable conversion from 'preferred_name::MemberTemplate<int>::const_iterator' to 'int'}}
620 
621   template<int A, int B, typename ...T> struct Foo;
622   template<typename ...T> using Bar = Foo<1, 2, T...>;
623   template<int A, int B, typename ...T> struct [[clang::preferred_name(::preferred_name::Bar<T...>)]] Foo {};
624   Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}
625 }
626 ::preferred_name::Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}
627