1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -Wno-unused-value -fcxx-exceptions -std=gnu++17 -ast-dump %s | FileCheck -strict-whitespace %s
2 
3 namespace std {
4 using size_t = decltype(sizeof(0));
5 
6 class type_info {
7 public:
8   virtual ~type_info();
9   bool operator==(const type_info& rhs) const noexcept;
10   bool operator!=(const type_info& rhs) const noexcept;
11   type_info(const type_info& rhs) = delete; // cannot be copied
12   type_info& operator=(const type_info& rhs) = delete; // cannot be copied
13 };
14 
15 class bad_typeid {
16 public:
17   bad_typeid() noexcept;
18   bad_typeid(const bad_typeid&) noexcept;
19   virtual ~bad_typeid();
20   bad_typeid& operator=(const bad_typeid&) noexcept;
21   const char* what() const noexcept;
22 };
23 } // namespace std
24 void *operator new(std::size_t, void *ptr);
25 
26 struct S {
27   virtual ~S() = default;
28 
29   void func(int);
30   template <typename Ty>
31   Ty foo();
32 
33   int i;
34 };
35 
36 struct T : S {};
37 
38 template <typename>
39 struct U {};
40 
41 void Throw() {
42   throw 12;
43   // CHECK: CXXThrowExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:9> 'void'
44   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:9> 'int' 12
45 
46   throw;
47   // CHECK: CXXThrowExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3> 'void'
48 }
49 
50 void PointerToMember(S obj1, S *obj2, int S::* data, void (S::*call)(int)) {
51   obj1.*data;
52   // CHECK: BinaryOperator 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:9> 'int' lvalue '.*'
53   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S' lvalue ParmVar 0x{{[^ ]*}} 'obj1' 'S'
54   // CHECK-NEXT: ImplicitCastExpr
55   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:9> 'int S::*' lvalue ParmVar 0x{{[^ ]*}} 'data' 'int S::*'
56 
57   obj2->*data;
58   // CHECK: BinaryOperator 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:10> 'int' lvalue '->*'
59   // CHECK-NEXT: ImplicitCastExpr
60   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'obj2' 'S *'
61   // CHECK-NEXT: ImplicitCastExpr
62   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:10> 'int S::*' lvalue ParmVar 0x{{[^ ]*}} 'data' 'int S::*'
63 
64   (obj1.*call)(12);
65   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:18> 'void'
66   // CHECK-NEXT: ParenExpr 0x{{[^ ]*}} <col:3, col:14> '<bound member function type>'
67   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:4, col:10> '<bound member function type>' '.*'
68   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'S' lvalue ParmVar 0x{{[^ ]*}} 'obj1' 'S'
69   // CHECK-NEXT: ImplicitCastExpr
70   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:10> 'void (S::*)(int)' lvalue ParmVar 0x{{[^ ]*}} 'call' 'void (S::*)(int)'
71   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:16> 'int' 12
72 
73   (obj2->*call)(12);
74   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:19> 'void'
75   // CHECK-NEXT: ParenExpr 0x{{[^ ]*}} <col:3, col:15> '<bound member function type>'
76   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:4, col:11> '<bound member function type>' '->*'
77   // CHECK-NEXT: ImplicitCastExpr
78   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'obj2' 'S *'
79   // CHECK-NEXT: ImplicitCastExpr
80   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:11> 'void (S::*)(int)' lvalue ParmVar 0x{{[^ ]*}} 'call' 'void (S::*)(int)'
81   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:17> 'int' 12
82 }
83 
84 void Casting(const S *s) {
85   // FIXME: The cast expressions contain "struct S" instead of "S".
86 
87   const_cast<S *>(s);
88   // CHECK: CXXConstCastExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:20> 'S *' const_cast<struct S *> <NoOp>
89   // CHECK-NEXT: ImplicitCastExpr 0x{{[^ ]*}} <col:19> 'const S *' <LValueToRValue> part_of_explicit_cast
90   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:19> 'const S *' lvalue ParmVar 0x{{[^ ]*}} 's' 'const S *'
91 
92   static_cast<const T *>(s);
93   // CHECK: CXXStaticCastExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:27> 'const T *' static_cast<const struct T *> <BaseToDerived (S)>
94   // CHECK-NEXT: ImplicitCastExpr 0x{{[^ ]*}} <col:26> 'const S *' <LValueToRValue> part_of_explicit_cast
95   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:26> 'const S *' lvalue ParmVar 0x{{[^ ]*}} 's' 'const S *'
96 
97   dynamic_cast<const T *>(s);
98   // CHECK: CXXDynamicCastExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:28> 'const T *' dynamic_cast<const struct T *> <Dynamic>
99   // CHECK-NEXT: ImplicitCastExpr 0x{{[^ ]*}} <col:27> 'const S *' <LValueToRValue> part_of_explicit_cast
100   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:27> 'const S *' lvalue ParmVar 0x{{[^ ]*}} 's' 'const S *'
101 
102   reinterpret_cast<const int *>(s);
103   // CHECK: CXXReinterpretCastExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:34> 'const int *' reinterpret_cast<const int *> <BitCast>
104   // CHECK-NEXT: ImplicitCastExpr 0x{{[^ ]*}} <col:33> 'const S *' <LValueToRValue> part_of_explicit_cast
105   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:33> 'const S *' lvalue ParmVar 0x{{[^ ]*}} 's' 'const S *'
106 }
107 
108 template <typename... Ts>
109 void UnaryExpressions(int *p) {
110   sizeof...(Ts);
111   // CHECK: SizeOfPackExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:15> 'unsigned long' 0x{{[^ ]*}} Ts
112 
113   noexcept(p - p);
114   // CHECK: CXXNoexceptExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:17> 'bool'
115   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:12, col:16> 'long' '-'
116   // CHECK-NEXT: ImplicitCastExpr
117   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:12> 'int *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'int *'
118   // CHECK-NEXT: ImplicitCastExpr
119   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'int *'
120 
121   ::new int;
122   // CHECK: CXXNewExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:9> 'int *' global Function 0x{{[^ ]*}} 'operator new' 'void *(unsigned long)'
123 
124   new (int);
125   // CHECK: CXXNewExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> 'int *' Function 0x{{[^ ]*}} 'operator new' 'void *(unsigned long)'
126 
127   new int{12};
128   // CHECK: CXXNewExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:13> 'int *' Function 0x{{[^ ]*}} 'operator new' 'void *(unsigned long)'
129   // CHECK-NEXT: InitListExpr 0x{{[^ ]*}} <col:10, col:13> 'int'
130   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 12
131 
132   new int[2];
133   // CHECK: CXXNewExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:12> 'int *' array Function 0x{{[^ ]*}} 'operator new[]' 'void *(unsigned long)'
134   // CHECK-NEXT: ImplicitCastExpr
135   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 2
136 
137   new int[2]{1, 2};
138   // CHECK: CXXNewExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:18> 'int *' array Function 0x{{[^ ]*}} 'operator new[]' 'void *(unsigned long)'
139   // CHECK-NEXT: ImplicitCastExpr
140   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 2
141   // CHECK-NEXT: InitListExpr 0x{{[^ ]*}} <col:13, col:18> 'int [2]'
142   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:14> 'int' 1
143   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:17> 'int' 2
144 
145   new (p) int;
146   // CHECK: CXXNewExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> 'int *' Function 0x{{[^ ]*}} 'operator new' 'void *(std::size_t, void *)'
147   // CHECK-NEXT: ImplicitCastExpr {{.*}} 'void *' <BitCast>
148   // CHECK-NEXT: ImplicitCastExpr {{.*}} 'int *' <LValueToRValue>
149   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:8> 'int *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'int *'
150 
151   new (p) int{12};
152   // CHECK: CXXNewExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:17> 'int *' Function 0x{{[^ ]*}} 'operator new' 'void *(std::size_t, void *)'
153   // CHECK-NEXT: InitListExpr 0x{{[^ ]*}} <col:14, col:17> 'int'
154   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:15> 'int' 12
155   // CHECK-NEXT: ImplicitCastExpr {{.*}} 'void *' <BitCast>
156   // CHECK-NEXT: ImplicitCastExpr {{.*}} 'int *' <LValueToRValue>
157   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:8> 'int *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'int *'
158 
159   ::delete p;
160   // CHECK: CXXDeleteExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:12> 'void' global Function 0x{{[^ ]*}} 'operator delete' 'void (void *) noexcept'
161   // CHECK-NEXT: ImplicitCastExpr
162   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:12> 'int *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'int *'
163 
164   delete [] p;
165   // CHECK: CXXDeleteExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:13> 'void' array Function 0x{{[^ ]*}} 'operator delete[]' 'void (void *) noexcept'
166   // CHECK-NEXT: ImplicitCastExpr
167   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:13> 'int *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'int *'
168 }
169 
170 void PostfixExpressions(S a, S *p, U<int> *r) {
171   a.func(0);
172   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> 'void'
173   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:5> '<bound member function type>' .func 0x{{[^ ]*}}
174   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S' lvalue ParmVar 0x{{[^ ]*}} 'a' 'S'
175   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:10> 'int' 0
176 
177   p->func(0);
178   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:12> 'void'
179   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:6> '<bound member function type>' ->func 0x{{[^ ]*}}
180   // CHECK-NEXT: ImplicitCastExpr
181   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'S *'
182   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 0
183 
184   // FIXME: there is no mention that this used the template keyword.
185   p->template foo<int>();
186   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:24> 'int':'int'
187   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:22> '<bound member function type>' ->foo 0x{{[^ ]*}}
188   // CHECK-NEXT: ImplicitCastExpr
189   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'S *'
190 
191   // FIXME: there is no mention that this used the template keyword.
192   a.template foo<float>();
193   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:25> 'float':'float'
194   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:23> '<bound member function type>' .foo 0x{{[^ ]*}}
195   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S' lvalue ParmVar 0x{{[^ ]*}} 'a' 'S'
196 
197   p->~S();
198   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:9> 'void'
199   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:7> '<bound member function type>' ->~S 0x{{[^ ]*}}
200   // CHECK-NEXT: ImplicitCastExpr
201   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'S *'
202 
203   a.~S();
204   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:8> 'void'
205   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:6> '<bound member function type>' .~S 0x{{[^ ]*}}
206   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S' lvalue ParmVar 0x{{[^ ]*}} 'a' 'S'
207 
208   // FIXME: there seems to be no way to distinguish the construct below from
209   // the construct above.
210   a.~decltype(a)();
211   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:18> 'void'
212   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:5> '<bound member function type>' .~S 0x{{[^ ]*}}
213   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S' lvalue ParmVar 0x{{[^ ]*}} 'a' 'S'
214 
215   // FIXME: similarly, there is no way to distinguish the construct below from
216   // the p->~S() case.
217   p->::S::~S();
218   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:14> 'void'
219   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:12> '<bound member function type>' ->~S 0x{{[^ ]*}}
220   // CHECK-NEXT: ImplicitCastExpr
221   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'S *'
222 
223   // FIXME: there is no mention that this used the template keyword.
224   r->template U<int>::~U();
225   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:26> 'void'
226   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:24> '<bound member function type>' ->~U 0x{{[^ ]*}}
227   // CHECK-NEXT: ImplicitCastExpr
228   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'U<int> *' lvalue ParmVar 0x{{[^ ]*}} 'r' 'U<int> *'
229 
230   typeid(a);
231   // CHECK: CXXTypeidExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> 'const std::type_info' lvalue
232   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:10> 'S' lvalue ParmVar 0x{{[^ ]*}} 'a' 'S'
233 
234   // FIXME: no type information is printed for the argument.
235   typeid(S);
236   // CHECK: CXXTypeidExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> 'const std::type_info' lvalue
237 }
238 
239 template <typename... Ts>
240 void PrimaryExpressions(Ts... a) {
241   struct V {
242     void f() {
243       this;
244       // CHECK: CXXThisExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:7> 'V *' this
245       [this]{};
246       // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:7, col:14>
247       // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:7> col:7 implicit class definition
248       // CHECK-NEXT: DefinitionData lambda
249       // CHECK-NEXT: DefaultConstructor
250       // CHECK-NEXT: CopyConstructor
251       // CHECK-NEXT: MoveConstructor
252       // CHECK-NEXT: CopyAssignment
253       // CHECK-NEXT: MoveAssignment
254       // CHECK-NEXT: Destructor
255       // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:8> col:8 implicit 'V *'
256       // CHECK-NEXT: CXXMethodDecl
257       // CHECK-NEXT: CompoundStmt
258       // CHECK-NEXT: CXXThisExpr 0x{{[^ ]*}} <col:8> 'V *' this
259 
260       [*this]{};
261       // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:7, col:15>
262       // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:7> col:7 implicit class definition
263       // CHECK-NEXT: DefinitionData lambda
264       // CHECK-NEXT: DefaultConstructor
265       // CHECK-NEXT: CopyConstructor
266       // CHECK-NEXT: MoveConstructor
267       // CHECK-NEXT: CopyAssignment
268       // CHECK-NEXT: MoveAssignment
269       // CHECK-NEXT: Destructor
270       // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:8> col:8 implicit 'V'
271       // CHECK-NEXT: CXXMethodDecl
272       // CHECK-NEXT: CompoundStmt
273       // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:8> 'NULL TYPE'
274       // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:8> '<dependent type>' prefix '*' cannot overflow
275       // CHECK-NEXT: CXXThisExpr 0x{{[^ ]*}} <col:8> 'V *' this
276     }
277   };
278 
279   int b, c;
280 
281   [](){};
282   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:8> '(lambda at {{.*}}:[[@LINE-1]]:3)'
283   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
284   // CHECK-NEXT: DefinitionData lambda
285   // CHECK-NEXT: DefaultConstructor
286   // CHECK-NEXT: CopyConstructor
287   // CHECK-NEXT: MoveConstructor
288   // CHECK-NEXT: CopyAssignment
289   // CHECK-NEXT: MoveAssignment
290   // CHECK-NEXT: Destructor
291   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:6, col:8> col:3 operator() 'auto () const' inline
292   // CHECK-NEXT: CompoundStmt
293   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:8> col:3 implicit constexpr operator auto (*)() 'auto (*() const)()' inline
294   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:8> col:3 implicit __invoke 'auto ()' static inline
295   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:7, col:8>
296 
297   [a...]{};
298   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:10> '(lambda at {{.*}}:[[@LINE-1]]:3)'
299   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
300   // CHECK-NEXT: DefinitionData lambda
301   // CHECK-NEXT: DefaultConstructor
302   // CHECK-NEXT: CopyConstructor
303   // CHECK-NEXT: MoveConstructor
304   // CHECK-NEXT: CopyAssignment
305   // CHECK-NEXT: MoveAssignment
306   // CHECK-NEXT: Destructor
307   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:4> col:4 implicit 'Ts...'
308   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:10> col:3 operator() 'auto () const -> auto' inline
309   // CHECK-NEXT: CompoundStmt
310   // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:4> 'NULL TYPE'
311   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
312   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:9, col:10>
313 
314   [=]{};
315   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> '(lambda at {{.*}}:[[@LINE-1]]:3)'
316   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
317   // CHECK-NEXT: DefinitionData lambda
318   // CHECK-NEXT: DefaultConstructor
319   // CHECK-NEXT: CopyConstructor
320   // CHECK-NEXT: MoveConstructor
321   // CHECK-NEXT: CopyAssignment
322   // CHECK-NEXT: MoveAssignment
323   // CHECK-NEXT: Destructor
324   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:5, col:7> col:3 operator() 'auto () const -> auto' inline
325   // CHECK-NEXT: CompoundStmt
326   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:6, col:7>
327 
328   [=] { return b; };
329   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:19> '(lambda at {{.*}}:[[@LINE-1]]:3)'
330   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
331   // CHECK-NEXT: DefinitionData lambda
332   // CHECK-NEXT: DefaultConstructor
333   // CHECK-NEXT: CopyConstructor
334   // CHECK-NEXT: MoveConstructor
335   // CHECK-NEXT: CopyAssignment
336   // CHECK-NEXT: MoveAssignment
337   // CHECK-NEXT: Destructor
338   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:5, col:19> col:3 operator() 'auto () const -> auto' inline
339   // CHECK-NEXT: CompoundStmt
340   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:9, col:16>
341   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'const int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
342   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:7, col:19>
343   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:9, col:16>
344   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'const int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
345 
346   [&]{};
347   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> '(lambda at {{.*}}:[[@LINE-1]]:3)'
348   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
349   // CHECK-NEXT: DefinitionData lambda
350   // CHECK-NEXT: DefaultConstructor
351   // CHECK-NEXT: CopyConstructor
352   // CHECK-NEXT: MoveConstructor
353   // CHECK-NEXT: CopyAssignment
354   // CHECK-NEXT: MoveAssignment
355   // CHECK-NEXT: Destructor
356   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:5, col:7> col:3 operator() 'auto () const -> auto' inline
357   // CHECK-NEXT: CompoundStmt
358   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:6, col:7>
359 
360   [&] { return c; };
361   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:19> '(lambda at {{.*}}:[[@LINE-1]]:3)'
362   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
363   // CHECK-NEXT: DefinitionData lambda
364   // CHECK-NEXT: DefaultConstructor
365   // CHECK-NEXT: CopyConstructor
366   // CHECK-NEXT: MoveConstructor
367   // CHECK-NEXT: CopyAssignment
368   // CHECK-NEXT: MoveAssignment
369   // CHECK-NEXT: Destructor
370   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:5, col:19> col:3 operator() 'auto () const -> auto' inline
371   // CHECK-NEXT: CompoundStmt
372   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:9, col:16>
373   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
374   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:7, col:19>
375   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:9, col:16>
376   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
377 
378   [b, &c]{ return b + c; };
379   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:26> '(lambda at {{.*}}:[[@LINE-1]]:3)'
380   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
381   // CHECK-NEXT: DefinitionData lambda
382   // CHECK-NEXT: DefaultConstructor
383   // CHECK-NEXT: CopyConstructor
384   // CHECK-NEXT: MoveConstructor
385   // CHECK-NEXT: CopyAssignment
386   // CHECK-NEXT: MoveAssignment
387   // CHECK-NEXT: Destructor
388   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:4> col:4 implicit 'int'
389   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:8> col:8 implicit 'int &'
390   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:9, col:26> col:3 operator() 'auto () const -> auto' inline
391   // CHECK-NEXT: CompoundStmt
392   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:12, col:23>
393   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:19, col:23> 'int' '+'
394   // CHECK-NEXT: ImplicitCastExpr
395   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:19> 'const int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
396   // CHECK-NEXT: ImplicitCastExpr
397   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
398   // CHECK-NEXT: ImplicitCastExpr
399   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
400   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:8> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
401   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:10, col:26>
402   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:12, col:23>
403   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:19, col:23> 'int' '+'
404   // CHECK-NEXT: ImplicitCastExpr
405   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:19> 'const int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
406   // CHECK-NEXT: ImplicitCastExpr
407   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
408 
409   [a..., x = 12]{};
410   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:18> '(lambda at {{.*}}:[[@LINE-1]]:3)'
411   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
412   // CHECK-NEXT: DefinitionData lambda
413   // CHECK-NEXT: DefaultConstructor
414   // CHECK-NEXT: CopyConstructor
415   // CHECK-NEXT: MoveConstructor
416   // CHECK-NEXT: CopyAssignment
417   // CHECK-NEXT: MoveAssignment
418   // CHECK-NEXT: Destructor
419   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:4> col:4 implicit 'Ts...'
420   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:10> col:10 implicit 'int':'int'
421   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:16, col:18> col:3 operator() 'auto () const -> auto' inline
422   // CHECK-NEXT: CompoundStmt
423   // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:4> 'NULL TYPE'
424   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
425   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:14> 'int' 12
426   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:17, col:18>
427 
428   []() constexpr {};
429   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:19> '(lambda at {{.*}}:[[@LINE-1]]:3)'
430   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
431   // CHECK-NEXT: DefinitionData lambda
432   // CHECK-NEXT: DefaultConstructor
433   // CHECK-NEXT: CopyConstructor
434   // CHECK-NEXT: MoveConstructor
435   // CHECK-NEXT: CopyAssignment
436   // CHECK-NEXT: MoveAssignment
437   // CHECK-NEXT: Destructor
438   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:19> col:3 constexpr operator() 'auto () const' inline
439   // CHECK-NEXT: CompoundStmt
440   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:19> col:3 implicit constexpr operator auto (*)() 'auto (*() const)()' inline
441   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:19> col:3 implicit __invoke 'auto ()' static inline
442   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:18, col:19>
443 
444   []() mutable {};
445   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:17> '(lambda at {{.*}}:[[@LINE-1]]:3)'
446   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
447   // CHECK-NEXT: DefinitionData lambda
448   // CHECK-NEXT: DefaultConstructor
449   // CHECK-NEXT: CopyConstructor
450   // CHECK-NEXT: MoveConstructor
451   // CHECK-NEXT: CopyAssignment
452   // CHECK-NEXT: MoveAssignment
453   // CHECK-NEXT: Destructor
454   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:17> col:3 operator() 'auto ()' inline
455   // CHECK-NEXT: CompoundStmt
456   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:17> col:3 implicit constexpr operator auto (*)() 'auto (*() const)()' inline
457   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:17> col:3 implicit __invoke 'auto ()' static inline
458   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:16, col:17>
459 
460   []() noexcept {};
461   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:18> '(lambda at {{.*}}:[[@LINE-1]]:3)'
462   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
463   // CHECK-NEXT: DefinitionData lambda
464   // CHECK-NEXT: DefaultConstructor
465   // CHECK-NEXT: CopyConstructor
466   // CHECK-NEXT: MoveConstructor
467   // CHECK-NEXT: CopyAssignment
468   // CHECK-NEXT: MoveAssignment
469   // CHECK-NEXT: Destructor
470   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:18> col:3 operator() 'auto () const noexcept' inline
471   // CHECK-NEXT: CompoundStmt
472   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:18> col:3 implicit constexpr operator auto (*)() noexcept 'auto (*() const)() noexcept' inline
473   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:18> col:3 implicit __invoke 'auto () noexcept' static inline
474   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:17, col:18>
475 
476   []() -> int { return 0; };
477   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:27> '(lambda at {{.*}}:[[@LINE-1]]:3)'
478   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
479   // CHECK-NEXT: DefinitionData lambda
480   // CHECK-NEXT: DefaultConstructor
481   // CHECK-NEXT: CopyConstructor
482   // CHECK-NEXT: MoveConstructor
483   // CHECK-NEXT: CopyAssignment
484   // CHECK-NEXT: MoveAssignment
485   // CHECK-NEXT: Destructor
486   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:11, col:27> col:3 operator() 'auto () const -> int' inline
487   // CHECK-NEXT: CompoundStmt
488   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:17, col:24>
489   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:24> 'int' 0
490   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:27> col:3 implicit constexpr operator int (*)() 'auto (*() const)() -> int' inline
491   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:27> col:3 implicit __invoke 'auto () -> int' static inline
492   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:15, col:27>
493   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:17, col:24>
494   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:24> 'int' 0
495 
496   (a + ...);
497   // CHECK: CXXFoldExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> '<dependent type>'
498   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
499   // CHECK-NEXT: <<<NULL>>>
500 
501   (... + a);
502   // CHECK: CXXFoldExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> '<dependent type>'
503   // CHECK-NEXT: <<<NULL>>>
504   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:10> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
505 
506   (a + ... + b);
507   // CHECK: CXXFoldExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:15> '<dependent type>'
508   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
509   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
510 }
511 
512 
513 namespace NS {
514 struct X {};
515 void f(X);
516 void y(...);
517 } // namespace NS
518 
519 // CHECK-LABEL: FunctionDecl 0x{{[^ ]*}} {{.*}}ADLCall 'void ()'
520 void ADLCall() {
521   NS::X x;
522   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void' adl{{$}}
523   f(x);
524   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void' adl{{$}}
525   y(x);
526 }
527 
528 // CHECK-LABEL: FunctionDecl 0x{{[^ ]*}} {{.*}}NonADLCall 'void ()'
529 void NonADLCall() {
530   NS::X x;
531   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void'{{$}}
532   NS::f(x);
533 }
534 
535 // CHECK-LABEL: FunctionDecl 0x{{[^ ]*}} {{.*}}NonADLCall2 'void ()'
536 void NonADLCall2() {
537   NS::X x;
538   using NS::f;
539   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void'{{$}}
540   f(x);
541   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void' adl{{$}}
542   y(x);
543 }
544 
545 namespace test_adl_call_three {
546 using namespace NS;
547 // CHECK-LABEL: FunctionDecl 0x{{[^ ]*}} {{.*}}NonADLCall3 'void ()'
548 void NonADLCall3() {
549   X x;
550   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void'{{$}}
551   f(x);
552 }
553 } // namespace test_adl_call_three