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