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: CXXMethodDecl
256       // CHECK-NEXT: CompoundStmt
257       // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:8> col:8 implicit 'V *'
258       // CHECK-NEXT: ParenListExpr
259       // CHECK-NEXT: CXXThisExpr 0x{{[^ ]*}} <col:8> 'V *' this
260 
261       [*this]{};
262       // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:7, col:15>
263       // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:7> col:7 implicit class definition
264       // CHECK-NEXT: DefinitionData lambda
265       // CHECK-NEXT: DefaultConstructor
266       // CHECK-NEXT: CopyConstructor
267       // CHECK-NEXT: MoveConstructor
268       // CHECK-NEXT: CopyAssignment
269       // CHECK-NEXT: MoveAssignment
270       // CHECK-NEXT: Destructor
271       // CHECK-NEXT: CXXMethodDecl
272       // CHECK-NEXT: CompoundStmt
273       // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:8> col:8 implicit 'V'
274       // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:8> 'NULL TYPE'
275       // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:8> '<dependent type>' prefix '*' cannot overflow
276       // CHECK-NEXT: CXXThisExpr 0x{{[^ ]*}} <col:8> 'V *' this
277     }
278   };
279 
280   int b, c;
281 
282   [](){};
283   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:8> '(lambda at {{.*}}:[[@LINE-1]]:3)'
284   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
285   // CHECK-NEXT: DefinitionData lambda
286   // CHECK-NEXT: DefaultConstructor
287   // CHECK-NEXT: CopyConstructor
288   // CHECK-NEXT: MoveConstructor
289   // CHECK-NEXT: CopyAssignment
290   // CHECK-NEXT: MoveAssignment
291   // CHECK-NEXT: Destructor
292   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:6, col:8> col:3 operator() 'auto () const' inline
293   // CHECK-NEXT: CompoundStmt
294   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:8> col:3 implicit constexpr operator auto (*)() 'auto (*() const noexcept)()' inline
295   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:8> col:3 implicit __invoke 'auto ()' static inline
296   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:7, col:8>
297 
298   [](int a, ...){};
299   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:18> '(lambda at {{.*}}:[[@LINE-1]]:3)'
300   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
301   // CHECK-NEXT: DefinitionData lambda
302   // CHECK-NEXT: DefaultConstructor
303   // CHECK-NEXT: CopyConstructor
304   // CHECK-NEXT: MoveConstructor
305   // CHECK-NEXT: CopyAssignment
306   // CHECK-NEXT: MoveAssignment
307   // CHECK-NEXT: Destructor
308   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:16, col:18> col:3 operator() 'auto (int, ...) const' inline
309   // CHECK-NEXT: ParmVarDecl 0x{{[^ ]*}} <col:6, col:10> col:10 a 'int'
310   // CHECK-NEXT: CompoundStmt
311   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:18> col:3 implicit constexpr operator auto (*)(int, ...) 'auto (*() const noexcept)(int, ...)' inline
312   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:18> col:3 implicit __invoke 'auto (int, ...)' static inline
313   // CHECK-NEXT: ParmVarDecl 0x{{[^ ]*}} <col:6, col:10> col:10 a 'int'
314   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:17, col:18>
315 
316   [a...]{};
317   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:10> '(lambda at {{.*}}:[[@LINE-1]]:3)'
318   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
319   // CHECK-NEXT: DefinitionData lambda
320   // CHECK-NEXT: DefaultConstructor
321   // CHECK-NEXT: CopyConstructor
322   // CHECK-NEXT: MoveConstructor
323   // CHECK-NEXT: CopyAssignment
324   // CHECK-NEXT: MoveAssignment
325   // CHECK-NEXT: Destructor
326   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:10> col:3 operator() 'auto () const -> auto' inline
327   // CHECK-NEXT: CompoundStmt
328   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:4> col:4 implicit 'Ts...'
329   // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:4> 'NULL TYPE'
330   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
331   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:9, col:10>
332 
333   [=]{};
334   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> '(lambda at {{.*}}:[[@LINE-1]]:3)'
335   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
336   // CHECK-NEXT: DefinitionData lambda
337   // CHECK-NEXT: DefaultConstructor
338   // CHECK-NEXT: CopyConstructor
339   // CHECK-NEXT: MoveConstructor
340   // CHECK-NEXT: CopyAssignment
341   // CHECK-NEXT: MoveAssignment
342   // CHECK-NEXT: Destructor
343   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:5, col:7> col:3 operator() 'auto () const -> auto' inline
344   // CHECK-NEXT: CompoundStmt
345   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:6, col:7>
346 
347   [=] { return b; };
348   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:19> '(lambda at {{.*}}:[[@LINE-1]]:3)'
349   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
350   // CHECK-NEXT: DefinitionData lambda
351   // CHECK-NEXT: DefaultConstructor
352   // CHECK-NEXT: CopyConstructor
353   // CHECK-NEXT: MoveConstructor
354   // CHECK-NEXT: CopyAssignment
355   // CHECK-NEXT: MoveAssignment
356   // CHECK-NEXT: Destructor
357   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:5, col:19> col:3 operator() 'auto () const -> auto' inline
358   // CHECK-NEXT: CompoundStmt
359   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:9, col:16>
360   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'const int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
361   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:7, col:19>
362   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:9, col:16>
363   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'const int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
364 
365   [&]{};
366   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> '(lambda at {{.*}}:[[@LINE-1]]:3)'
367   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
368   // CHECK-NEXT: DefinitionData lambda
369   // CHECK-NEXT: DefaultConstructor
370   // CHECK-NEXT: CopyConstructor
371   // CHECK-NEXT: MoveConstructor
372   // CHECK-NEXT: CopyAssignment
373   // CHECK-NEXT: MoveAssignment
374   // CHECK-NEXT: Destructor
375   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:5, col:7> col:3 operator() 'auto () const -> auto' inline
376   // CHECK-NEXT: CompoundStmt
377   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:6, col:7>
378 
379   [&] { return c; };
380   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:19> '(lambda at {{.*}}:[[@LINE-1]]:3)'
381   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
382   // CHECK-NEXT: DefinitionData lambda
383   // CHECK-NEXT: DefaultConstructor
384   // CHECK-NEXT: CopyConstructor
385   // CHECK-NEXT: MoveConstructor
386   // CHECK-NEXT: CopyAssignment
387   // CHECK-NEXT: MoveAssignment
388   // CHECK-NEXT: Destructor
389   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:5, col:19> col:3 operator() 'auto () const -> auto' inline
390   // CHECK-NEXT: CompoundStmt
391   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:9, col:16>
392   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
393   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:7, col:19>
394   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:9, col:16>
395   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
396 
397   [b, &c]{ return b + c; };
398   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:26> '(lambda at {{.*}}:[[@LINE-1]]:3)'
399   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
400   // CHECK-NEXT: DefinitionData lambda
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: CXXMethodDecl 0x{{[^ ]*}} <col:9, col:26> col:3 operator() 'auto () const -> auto' inline
408   // CHECK-NEXT: CompoundStmt
409   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:12, col:23>
410   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:19, col:23> 'int' '+'
411   // CHECK-NEXT: ImplicitCastExpr
412   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:19> 'const int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
413   // CHECK-NEXT: ImplicitCastExpr
414   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
415   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:4> col:4 implicit 'int'
416   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:8> col:8 implicit 'int &'
417   // CHECK-NEXT: ImplicitCastExpr
418   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
419   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:8> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
420   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:10, col:26>
421   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:12, col:23>
422   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:19, col:23> 'int' '+'
423   // CHECK-NEXT: ImplicitCastExpr
424   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:19> 'const int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
425   // CHECK-NEXT: ImplicitCastExpr
426   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int' lvalue Var 0x{{[^ ]*}} 'c' 'int'
427 
428   [a..., x = 12]{};
429   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:18> '(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:16, col:18> col:3 operator() 'auto () const -> auto' inline
439   // CHECK-NEXT: CompoundStmt
440   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:4> col:4 implicit 'Ts...'
441   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:10> col:10 implicit 'int':'int'
442   // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:4> 'NULL TYPE'
443   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
444   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:14> 'int' 12
445   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:17, col:18>
446 
447   []() constexpr {};
448   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:19> '(lambda at {{.*}}:[[@LINE-1]]:3)'
449   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
450   // CHECK-NEXT: DefinitionData lambda
451   // CHECK-NEXT: DefaultConstructor
452   // CHECK-NEXT: CopyConstructor
453   // CHECK-NEXT: MoveConstructor
454   // CHECK-NEXT: CopyAssignment
455   // CHECK-NEXT: MoveAssignment
456   // CHECK-NEXT: Destructor
457   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:19> col:3 constexpr operator() 'auto () const' inline
458   // CHECK-NEXT: CompoundStmt
459   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:19> col:3 implicit constexpr operator auto (*)() 'auto (*() const noexcept)()' inline
460   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:19> col:3 implicit __invoke 'auto ()' static inline
461   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:18, col:19>
462 
463   []() mutable {};
464   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:17> '(lambda at {{.*}}:[[@LINE-1]]:3)'
465   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
466   // CHECK-NEXT: DefinitionData lambda
467   // CHECK-NEXT: DefaultConstructor
468   // CHECK-NEXT: CopyConstructor
469   // CHECK-NEXT: MoveConstructor
470   // CHECK-NEXT: CopyAssignment
471   // CHECK-NEXT: MoveAssignment
472   // CHECK-NEXT: Destructor
473   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:17> col:3 operator() 'auto ()' inline
474   // CHECK-NEXT: CompoundStmt
475   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:17> col:3 implicit constexpr operator auto (*)() 'auto (*() const noexcept)()' inline
476   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:17> col:3 implicit __invoke 'auto ()' static inline
477   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:16, col:17>
478 
479   []() noexcept {};
480   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:18> '(lambda at {{.*}}:[[@LINE-1]]:3)'
481   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
482   // CHECK-NEXT: DefinitionData lambda
483   // CHECK-NEXT: DefaultConstructor
484   // CHECK-NEXT: CopyConstructor
485   // CHECK-NEXT: MoveConstructor
486   // CHECK-NEXT: CopyAssignment
487   // CHECK-NEXT: MoveAssignment
488   // CHECK-NEXT: Destructor
489   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:18> col:3 operator() 'auto () const noexcept' inline
490   // CHECK-NEXT: CompoundStmt
491   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:18> col:3 implicit constexpr operator auto (*)() noexcept 'auto (*() const noexcept)() noexcept' inline
492   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:18> col:3 implicit __invoke 'auto () noexcept' static inline
493   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:17, col:18>
494 
495   []() -> int { return 0; };
496   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:27> '(lambda at {{.*}}:[[@LINE-1]]:3)'
497   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
498   // CHECK-NEXT: DefinitionData lambda
499   // CHECK-NEXT: DefaultConstructor
500   // CHECK-NEXT: CopyConstructor
501   // CHECK-NEXT: MoveConstructor
502   // CHECK-NEXT: CopyAssignment
503   // CHECK-NEXT: MoveAssignment
504   // CHECK-NEXT: Destructor
505   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:11, col:27> col:3 operator() 'auto () const -> int' inline
506   // CHECK-NEXT: CompoundStmt
507   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:17, col:24>
508   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:24> 'int' 0
509   // CHECK-NEXT: CXXConversionDecl 0x{{[^ ]*}} <col:3, col:27> col:3 implicit constexpr operator int (*)() 'auto (*() const noexcept)() -> int' inline
510   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:3, col:27> col:3 implicit __invoke 'auto () -> int' static inline
511   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:15, col:27>
512   // CHECK-NEXT: ReturnStmt 0x{{[^ ]*}} <col:17, col:24>
513   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:24> 'int' 0
514 
515   (a + ...);
516   // CHECK: CXXFoldExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> '<dependent type>'
517   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
518   // CHECK-NEXT: <<<NULL>>>
519 
520   (... + a);
521   // CHECK: CXXFoldExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> '<dependent type>'
522   // CHECK-NEXT: <<<NULL>>>
523   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:10> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
524 
525   (a + ... + b);
526   // CHECK: CXXFoldExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:15> '<dependent type>'
527   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts...' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
528   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int' lvalue Var 0x{{[^ ]*}} 'b' 'int'
529 }
530 
531 
532 namespace NS {
533 struct X {};
534 void f(X);
535 void y(...);
536 } // namespace NS
537 
538 // CHECK-LABEL: FunctionDecl 0x{{[^ ]*}} {{.*}}ADLCall 'void ()'
539 void ADLCall() {
540   NS::X x;
541   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void' adl{{$}}
542   f(x);
543   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void' adl{{$}}
544   y(x);
545 }
546 
547 // CHECK-LABEL: FunctionDecl 0x{{[^ ]*}} {{.*}}NonADLCall 'void ()'
548 void NonADLCall() {
549   NS::X x;
550   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void'{{$}}
551   NS::f(x);
552 }
553 
554 // CHECK-LABEL: FunctionDecl 0x{{[^ ]*}} {{.*}}NonADLCall2 'void ()'
555 void NonADLCall2() {
556   NS::X x;
557   using NS::f;
558   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void'{{$}}
559   f(x);
560   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void' adl{{$}}
561   y(x);
562 }
563 
564 namespace test_adl_call_three {
565 using namespace NS;
566 // CHECK-LABEL: FunctionDecl 0x{{[^ ]*}} {{.*}}NonADLCall3 'void ()'
567 void NonADLCall3() {
568   X x;
569   // CHECK: CallExpr 0x{{[^ ]*}} <line:[[@LINE+1]]:{{[^>]+}}> 'void'{{$}}
570   f(x);
571 }
572 } // namespace test_adl_call_three
573