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