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: InitListExpr {{.+}} <col:15> 'U' field Field {{.+}} 'i' 'int'
95 // CHECK-NEXT:   `-InitListExpr {{.+}} <col:14> 'U' field Field {{.+}} 'i' 'int'
96 // CHECK-NEXT:     `-IntegerLiteral {{.+}} <col:14> 'int' 1
97 }
98 
99 void TestSwitch(int i) {
100   switch (int a; i)
101     ;
102   // CHECK: SwitchStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5> has_init
103   // CHECK-NEXT: DeclStmt
104   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:11, col:15> col:15 a 'int'
105   // CHECK-NEXT: ImplicitCastExpr
106   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:18> 'int' lvalue ParmVar 0x{{[^ ]*}} 'i' 'int'
107   // CHECK-NEXT: NullStmt
108 }
109 
110 void TestIf(bool b) {
111   if (int i = 12; b)
112     ;
113   // CHECK: IfStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5> has_init
114   // CHECK-NEXT: DeclStmt
115   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:7, col:15> col:11 i 'int' cinit
116   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:15> 'int' 12
117   // CHECK-NEXT: ImplicitCastExpr
118   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:19> 'bool' lvalue ParmVar 0x{{[^ ]*}} 'b' 'bool'
119   // CHECK-NEXT: NullStmt
120 
121   if constexpr (sizeof(b) == 1)
122     ;
123   // CHECK: IfStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
124   // CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <line:[[@LINE-3]]:17, col:30> 'bool'
125   // CHECK-NEXT: BinaryOperator
126   // CHECK-NEXT: UnaryExprOrTypeTraitExpr
127   // CHECK-NEXT: ParenExpr
128   // CHECK-NEXT: DeclRefExpr
129   // CHECK-NEXT: ImplicitCastExpr
130   // CHECK-NEXT: IntegerLiteral
131   // CHECK-NEXT: NullStmt
132 
133   if constexpr (sizeof(b) == 1)
134     ;
135   else
136     ;
137   // CHECK: IfStmt 0x{{[^ ]*}} <line:[[@LINE-4]]:3, line:[[@LINE-1]]:5> has_else
138   // CHECK-NEXT: ConstantExpr 0x{{[^ ]*}} <line:[[@LINE-5]]:17, col:30> 'bool'
139   // CHECK-NEXT: BinaryOperator
140   // CHECK-NEXT: UnaryExprOrTypeTraitExpr
141   // CHECK-NEXT: ParenExpr
142   // CHECK-NEXT: DeclRefExpr
143   // CHECK-NEXT: ImplicitCastExpr
144   // CHECK-NEXT: IntegerLiteral
145   // CHECK-NEXT: NullStmt
146   // CHECK-NEXT: NullStmt
147 }
148 
149 struct Container {
150   int *begin() const;
151   int *end() const;
152 };
153 
154 void TestIteration() {
155   for (int i = 0; int j = i; ++i)
156     ;
157   // CHECK: ForStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
158   // CHECK-NEXT: DeclStmt
159   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:16> col:12 used i 'int' cinit
160   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:16> 'int' 0
161   // CHECK-NEXT: DeclStmt
162   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:19, col:27> col:23 used j 'int' cinit
163   // CHECK-NEXT: ImplicitCastExpr
164   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:27> 'int' lvalue Var 0x{{[^ ]*}} 'i' 'int'
165   // CHECK-NEXT: ImplicitCastExpr 0x{{[^ ]*}} <col:23> 'bool' <IntegralToBoolean>
166   // CHECK-NEXT: ImplicitCastExpr 0x{{[^ ]*}} <col:23> 'int' <LValueToRValue>
167   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int' lvalue Var 0x{{[^ ]*}} 'j' 'int'
168   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:30, col:32> 'int' lvalue prefix '++'
169   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:32> 'int' lvalue Var 0x{{[^ ]*}} 'i' 'int'
170   // CHECK-NEXT: NullStmt
171 
172   int vals[10];
173   for (int v : vals)
174     ;
175   // CHECK: CXXForRangeStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
176   // CHECK-NEXT: <<<NULL>>>
177   // CHECK-NEXT: DeclStmt
178   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:16> col:16 implicit used __range1 'int (&)[10]' cinit
179   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'int [10]' lvalue Var 0x{{[^ ]*}} 'vals' 'int [10]'
180   // CHECK-NEXT: DeclStmt
181   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14> col:14 implicit used __begin1 'int *':'int *' cinit
182   // CHECK-NEXT: ImplicitCastExpr
183   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
184   // CHECK-NEXT: DeclStmt
185   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14, col:16> col:14 implicit used __end1 'int *':'int *' cinit
186   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:14, col:16> 'int *' '+'
187   // CHECK-NEXT: ImplicitCastExpr
188   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
189   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:16> 'long' 10
190   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:14> 'bool' '!='
191   // CHECK-NEXT: ImplicitCastExpr
192   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
193   // CHECK-NEXT: ImplicitCastExpr
194   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__end1' 'int *':'int *'
195   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue prefix '++'
196   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
197   // CHECK-NEXT: DeclStmt
198   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:14> col:12 v 'int' cinit
199   // CHECK-NEXT: ImplicitCastExpr
200   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:14> 'int' lvalue prefix '*' cannot overflow
201   // CHECK-NEXT: ImplicitCastExpr
202   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
203   // CHECK-NEXT: NullStmt
204 
205   Container C;
206   for (int v : C)
207     ;
208   // CHECK: CXXForRangeStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
209   // CHECK-NEXT: <<<NULL>>>
210   // CHECK-NEXT: DeclStmt
211   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:16> col:16 implicit used __range1 'Container &' cinit
212   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:16> 'Container' lvalue Var 0x{{[^ ]*}} 'C' 'Container'
213   // CHECK-NEXT: DeclStmt
214   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14> col:14 implicit used __begin1 'int *':'int *' cinit
215   // CHECK-NEXT: CXXMemberCallExpr 0x{{[^ ]*}} <col:14> 'int *'
216   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:14> '<bound member function type>' .begin 0x{{[^ ]*}}
217   // CHECK-NEXT: ImplicitCastExpr
218   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'Container' lvalue Var 0x{{[^ ]*}} '__range1' 'Container &'
219   // CHECK-NEXT: DeclStmt
220   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:14> col:14 implicit used __end1 'int *':'int *' cinit
221   // CHECK-NEXT: CXXMemberCallExpr 0x{{[^ ]*}} <col:14> 'int *'
222   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:14> '<bound member function type>' .end 0x{{[^ ]*}}
223   // CHECK-NEXT: ImplicitCastExpr
224   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'Container' lvalue Var 0x{{[^ ]*}} '__range1' 'Container &'
225   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:14> 'bool' '!='
226   // CHECK-NEXT: ImplicitCastExpr
227   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
228   // CHECK-NEXT: ImplicitCastExpr
229   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__end1' 'int *':'int *'
230   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue prefix '++'
231   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
232   // CHECK-NEXT: DeclStmt
233   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:14> col:12 v 'int' cinit
234   // CHECK-NEXT: ImplicitCastExpr
235   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:14> 'int' lvalue prefix '*' cannot overflow
236   // CHECK-NEXT: ImplicitCastExpr
237   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:14> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
238   // CHECK-NEXT: NullStmt
239 
240   for (int a; int v : vals)
241     ;
242   // CHECK: CXXForRangeStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:5>
243   // CHECK-NEXT: DeclStmt
244   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:8, col:12> col:12 a 'int'
245   // CHECK-NEXT: DeclStmt
246   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:23> col:23 implicit used __range1 'int (&)[10]' cinit
247   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:23> 'int [10]' lvalue Var 0x{{[^ ]*}} 'vals' 'int [10]'
248   // CHECK-NEXT: DeclStmt
249   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:21> col:21 implicit used __begin1 'int *':'int *' cinit
250   // CHECK-NEXT: ImplicitCastExpr
251   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
252   // CHECK-NEXT: DeclStmt
253   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:21, col:23> col:21 implicit used __end1 'int *':'int *' cinit
254   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:21, col:23> 'int *' '+'
255   // CHECK-NEXT: ImplicitCastExpr
256   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int [10]' lvalue Var 0x{{[^ ]*}} '__range1' 'int (&)[10]'
257   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:23> 'long' 10
258   // CHECK-NEXT: BinaryOperator 0x{{[^ ]*}} <col:21> 'bool' '!='
259   // CHECK-NEXT: ImplicitCastExpr
260   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
261   // CHECK-NEXT: ImplicitCastExpr
262   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__end1' 'int *':'int *'
263   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue prefix '++'
264   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
265   // CHECK-NEXT: DeclStmt
266   // CHECK-NEXT: VarDecl 0x{{[^ ]*}} <col:15, col:21> col:19 v 'int' cinit
267   // CHECK-NEXT: ImplicitCastExpr
268   // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:21> 'int' lvalue prefix '*' cannot overflow
269   // CHECK-NEXT: ImplicitCastExpr
270   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:21> 'int *':'int *' lvalue Var 0x{{[^ ]*}} '__begin1' 'int *':'int *'
271   // CHECK-NEXT: NullStmt
272 }
273