1 // RUN: %clang_cc1 -std=c++2a -triple x86_64-linux-gnu -fcxx-exceptions -ast-dump %s | FileCheck -strict-whitespace %s
2 
3 namespace n {
4 void function() {}
5 int Variable;
6 }
7 using n::function;
8 using n::Variable;
9 void TestFunction() {
10   void (*f)() = &function;
11 // CHECK:       DeclRefExpr{{.*}} (UsingShadow{{.*}}function
12   Variable = 4;
13 // CHECK:       DeclRefExpr{{.*}} (UsingShadow{{.*}}Variable
14 }
15 
16 // CHECK: FunctionDecl {{.*}} TestCatch1
17 void TestCatch1() {
18 // CHECK:       CXXTryStmt
19 // CHECK-NEXT:    CompoundStmt
20   try {
21   }
22 // CHECK-NEXT:    CXXCatchStmt
23 // CHECK-NEXT:      VarDecl {{.*}} x
24 // CHECK-NEXT:      CompoundStmt
25   catch (int x) {
26   }
27 }
28 
29 // CHECK: FunctionDecl {{.*}} TestCatch2
30 void TestCatch2() {
31 // CHECK:       CXXTryStmt
32 // CHECK-NEXT:    CompoundStmt
33   try {
34   }
35 // CHECK-NEXT:    CXXCatchStmt
36 // CHECK-NEXT:      NULL
37 // CHECK-NEXT:      CompoundStmt
38   catch (...) {
39   }
40 }
41 
42 void TestAllocationExprs() {
43   int *p;
44   p = new int;
45   delete p;
46   p = new int[2];
47   delete[] p;
48   p = ::new int;
49   ::delete p;
50 }
51 // CHECK: FunctionDecl {{.*}} TestAllocationExprs
52 // CHECK: CXXNewExpr {{.*}} 'int *' Function {{.*}} 'operator new'
53 // CHECK: CXXDeleteExpr {{.*}} 'void' Function {{.*}} 'operator delete'
54 // CHECK: CXXNewExpr {{.*}} 'int *' array Function {{.*}} 'operator new[]'
55 // CHECK: CXXDeleteExpr {{.*}} 'void' array Function {{.*}} 'operator delete[]'
56 // CHECK: CXXNewExpr {{.*}} 'int *' global Function {{.*}} 'operator new'
57 // CHECK: CXXDeleteExpr {{.*}} 'void' global Function {{.*}} 'operator delete'
58 
59 // Don't crash on dependent exprs that haven't been resolved yet.
60 template <typename T>
61 void TestDependentAllocationExpr() {
62   T *p = new T;
63   delete p;
64 }
65 // CHECK: FunctionTemplateDecl {{.*}} TestDependentAllocationExpr
66 // CHECK: CXXNewExpr {{.*'T \*'$}}
67 // CHECK: CXXDeleteExpr {{.*'void'$}}
68 
69 template <typename T>
70 class DependentScopeMemberExprWrapper {
71   T member;
72 };
73 
74 template <typename T>
75 void TestDependentScopeMemberExpr() {
76   DependentScopeMemberExprWrapper<T> obj;
77   obj.member = T();
78   (&obj)->member = T();
79 }
80 // CHECK: FunctionTemplateDecl {{.*}} TestDependentScopeMemberExpr
81 // CHECK: CXXDependentScopeMemberExpr {{.*}} lvalue .member
82 // CHECK: CXXDependentScopeMemberExpr {{.*}} lvalue ->member
83 
84 union U {
85   int i;
86   long l;
87 };
88 
89 void TestUnionInitList()
90 {
91   U us[3] = {1};
92 // CHECK: VarDecl {{.+}} <col:3, col:15> col:5 us 'U [3]' cinit
93 // CHECK-NEXT: `-InitListExpr {{.+}} <col:13, col:15> 'U [3]'
94 // CHECK-NEXT:   |-array filler
95 // CHECK-NEXT:   | `-InitListExpr {{.+}} <col:15> 'U' field Field {{.+}} 'i' 'int'
96 // CHECK-NEXT:   `-InitListExpr {{.+}} <col:14> 'U' field Field {{.+}} 'i' 'int'
97 // CHECK-NEXT:     `-IntegerLiteral {{.+}} <col:14> 'int' 1
98 }
99 
100 void TestSwitch(int i) {
101   switch (int a; i)
102     ;
103   // CHECK: SwitchStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5> has_init
104   // CHECK-NEXT: DeclStmt
105   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:11, col:15> col:15 a 'int'
106   // CHECK-NEXT: ImplicitCastExpr
107   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:18> 'int' lvalue ParmVar 0x{{[^ ]*}} 'i' 'int'
108   // CHECK-NEXT: NullStmt
109 }
110 
111 void TestIf(bool b) {
112   if (int i = 12; b)
113     ;
114   // CHECK: IfStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5> has_init
115   // CHECK-NEXT: DeclStmt
116   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:7, col:15> col:11 i 'int' cinit
117   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:15> 'int' 12
118   // CHECK-NEXT: ImplicitCastExpr
119   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:19> 'bool' lvalue ParmVar 0x{{[^ ]*}} 'b' 'bool'
120   // CHECK-NEXT: NullStmt
121 
122   if constexpr (sizeof(b) == 1)
123     ;
124   // CHECK: IfStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
125   // CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <line:[[@LINE-3]]:17, col:30> 'bool'
126   // CHECK-NEXT: BinaryOperator
127   // CHECK-NEXT: UnaryExprOrTypeTraitExpr
128   // CHECK-NEXT: ParenExpr
129   // CHECK-NEXT: DeclRefExpr
130   // CHECK-NEXT: ImplicitCastExpr
131   // CHECK-NEXT: IntegerLiteral
132   // CHECK-NEXT: NullStmt
133 
134   if constexpr (sizeof(b) == 1)
135     ;
136   else
137     ;
138   // CHECK: IfStmt 0x{{[^ ]*}} <line:[[@LINE-4]]:3, line:[[@LINE-1]]:5> has_else
139   // CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <line:[[@LINE-5]]:17, col:30> 'bool'
140   // CHECK-NEXT: BinaryOperator
141   // CHECK-NEXT: UnaryExprOrTypeTraitExpr
142   // CHECK-NEXT: ParenExpr
143   // CHECK-NEXT: DeclRefExpr
144   // CHECK-NEXT: ImplicitCastExpr
145   // CHECK-NEXT: IntegerLiteral
146   // CHECK-NEXT: NullStmt
147   // CHECK-NEXT: NullStmt
148 }
149 
150 struct Container {
151   int *begin() const;
152   int *end() const;
153 };
154 
155 void TestIteration() {
156   for (int i = 0; int j = i; ++i)
157     ;
158   // CHECK: ForStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
159   // CHECK-NEXT: DeclStmt
160   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:16> col:12 used i 'int' cinit
161   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:16> 'int' 0
162   // CHECK-NEXT: DeclStmt
163   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:19, col:27> col:23 used j 'int' cinit
164   // CHECK-NEXT: ImplicitCastExpr
165   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:27> 'int' lvalue Var 0x{{[^ ]*}} 'i' 'int'
166   // CHECK-NEXT: ImplicitCastExpr 0x{{[^ ]*}} <col:23> 'bool' <IntegralToBoolean>
167   // CHECK-NEXT: ImplicitCastExpr 0x{{[^ ]*}} <col:23> 'int' <LValueToRValue>
168   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int' lvalue Var 0x{{[^ ]*}} 'j' 'int'
169   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:30, col:32> 'int' lvalue prefix '++'
170   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:32> 'int' lvalue Var 0x{{[^ ]*}} 'i' 'int'
171   // CHECK-NEXT: NullStmt
172 
173   int vals[10];
174   for (int v : vals)
175     ;
176   // CHECK: CXXForRangeStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
177   // CHECK-NEXT: <<<NULL>>>
178   // CHECK-NEXT: DeclStmt
179   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:16> col:16 implicit used __range1 'int (&)[10]' cinit
180   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int [10]' lvalue Var 0x{{[^ ]*}} 'vals' 'int [10]'
181   // CHECK-NEXT: DeclStmt
182   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14> col:14 implicit used __begin1 'int *':'int *' cinit
183   // CHECK-NEXT: ImplicitCastExpr
184   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
185   // CHECK-NEXT: DeclStmt
186   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14, col:16> col:14 implicit used __end1 'int *':'int *' cinit
187   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:14, col:16> 'int *' '+'
188   // CHECK-NEXT: ImplicitCastExpr
189   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
190   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:16> 'long' 10
191   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:14> 'bool' '!='
192   // CHECK-NEXT: ImplicitCastExpr
193   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
194   // CHECK-NEXT: ImplicitCastExpr
195   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__end1' 'int *':'int *'
196   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue prefix '++'
197   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
198   // CHECK-NEXT: DeclStmt
199   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:14> col:12 v 'int' cinit
200   // CHECK-NEXT: ImplicitCastExpr
201   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:14> 'int' lvalue prefix '*' cannot overflow
202   // CHECK-NEXT: ImplicitCastExpr
203   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
204   // CHECK-NEXT: NullStmt
205 
206   Container C;
207   for (int v : C)
208     ;
209   // CHECK: CXXForRangeStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
210   // CHECK-NEXT: <<<NULL>>>
211   // CHECK-NEXT: DeclStmt
212   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:16> col:16 implicit used __range1 'Container &' cinit
213   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'Container' lvalue Var 0x{{[^ ]*}} 'C' 'Container'
214   // CHECK-NEXT: DeclStmt
215   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14> col:14 implicit used __begin1 'int *':'int *' cinit
216   // CHECK-NEXT: CXXMemberCallExpr 0x{{[^ ]*}} <col:14> 'int *'
217   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:14> '<bound member function type>' .begin 0x{{[^ ]*}}
218   // CHECK-NEXT: ImplicitCastExpr
219   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'Container' lvalue Var 0x{{[^ ]*}} '__range1' 'Container &'
220   // CHECK-NEXT: DeclStmt
221   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14> col:14 implicit used __end1 'int *':'int *' cinit
222   // CHECK-NEXT: CXXMemberCallExpr 0x{{[^ ]*}} <col:14> 'int *'
223   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:14> '<bound member function type>' .end 0x{{[^ ]*}}
224   // CHECK-NEXT: ImplicitCastExpr
225   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'Container' lvalue Var 0x{{[^ ]*}} '__range1' 'Container &'
226   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:14> 'bool' '!='
227   // CHECK-NEXT: ImplicitCastExpr
228   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
229   // CHECK-NEXT: ImplicitCastExpr
230   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__end1' 'int *':'int *'
231   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue prefix '++'
232   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
233   // CHECK-NEXT: DeclStmt
234   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:14> col:12 v 'int' cinit
235   // CHECK-NEXT: ImplicitCastExpr
236   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:14> 'int' lvalue prefix '*' cannot overflow
237   // CHECK-NEXT: ImplicitCastExpr
238   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
239   // CHECK-NEXT: NullStmt
240 
241   for (int a; int v : vals)
242     ;
243   // CHECK: CXXForRangeStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
244   // CHECK-NEXT: DeclStmt
245   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:12> col:12 a 'int'
246   // CHECK-NEXT: DeclStmt
247   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:23> col:23 implicit used __range1 'int (&)[10]' cinit
248   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int [10]' lvalue Var 0x{{[^ ]*}} 'vals' 'int [10]'
249   // CHECK-NEXT: DeclStmt
250   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:21> col:21 implicit used __begin1 'int *':'int *' cinit
251   // CHECK-NEXT: ImplicitCastExpr
252   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
253   // CHECK-NEXT: DeclStmt
254   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:21, col:23> col:21 implicit used __end1 'int *':'int *' cinit
255   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:21, col:23> 'int *' '+'
256   // CHECK-NEXT: ImplicitCastExpr
257   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
258   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:23> 'long' 10
259   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:21> 'bool' '!='
260   // CHECK-NEXT: ImplicitCastExpr
261   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
262   // CHECK-NEXT: ImplicitCastExpr
263   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__end1' 'int *':'int *'
264   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue prefix '++'
265   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
266   // CHECK-NEXT: DeclStmt
267   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:15, col:21> col:19 v 'int' cinit
268   // CHECK-NEXT: ImplicitCastExpr
269   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:21> 'int' lvalue prefix '*' cannot overflow
270   // CHECK-NEXT: ImplicitCastExpr
271   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
272   // CHECK-NEXT: NullStmt
273 }
274