1 // RUN: %clang_cc1 -triple %ms_abi_triple -ast-print %s -std=gnu++11 | FileCheck %s
2
3 // CHECK: r;
4 // CHECK-NEXT: (r->method());
5 struct MyClass
6 {
methodMyClass7 void method() {}
8 };
9
10 struct Reference
11 {
12 MyClass* object;
operator ->Reference13 MyClass* operator ->() { return object; }
14 };
15
test1()16 void test1() {
17 Reference r;
18 (r->method());
19 }
20
21 // CHECK: if (int a = 1)
22 // CHECK: while (int a = 1)
23 // CHECK: switch (int a = 1)
24 // CHECK: for (; int a = 1;)
25
test2()26 void test2()
27 {
28 if (int a = 1) { }
29 while (int a = 1) { }
30 switch (int a = 1) { }
31 for(; int a = 1; ) { }
32 }
33
34 // CHECK: new (1) int;
35 void *operator new (typeof(sizeof(1)), int, int = 2);
test3()36 void test3() {
37 new (1) int;
38 }
39
40 // CHECK: new X;
41 struct X {
42 void *operator new (typeof(sizeof(1)), int = 2);
43 };
test4()44 void test4() { new X; }
45
46 // CHECK: for (int i = 2097, j = 42; false;)
test5()47 void test5() {
48 for (int i = 2097, j = 42; false;) {}
49 }
50
51 // CHECK: test6fn((int &)y);
52 void test6fn(int& x);
test6()53 void test6() {
54 unsigned int y = 0;
55 test6fn((int&)y);
56 }
57
58 // CHECK: S s(1, 2);
59
test7()60 template <class S> void test7()
61 {
62 S s( 1,2 );
63 }
64
65
66 // CHECK: t.~T();
67
test8(T t)68 template <typename T> void test8(T t) { t.~T(); }
69
70
71 // CHECK: enum E
72 // CHECK-NEXT: A,
73 // CHECK-NEXT: B,
74 // CHECK-NEXT: C
75 // CHECK-NEXT: };
76 // CHECK-NEXT: {{^[ ]+}}E a = A;
77
78 struct test9
79 {
ftest980 void f()
81 {
82 enum E { A, B, C };
83 E a = A;
84 }
85 };
86
87 namespace test10 {
88 namespace M {
89 template<typename T>
90 struct X {
91 enum { value };
92 };
93 }
94 }
95
96 typedef int INT;
97
98 // CHECK: test11
99 // CHECK-NEXT: return test10::M::X<INT>::value;
test11()100 int test11() {
101 return test10::M::X<INT>::value;
102 }
103
104
105 struct DefaultArgClass
106 {
DefaultArgClassDefaultArgClass107 DefaultArgClass(int a = 1) {}
DefaultArgClassDefaultArgClass108 DefaultArgClass(int a, int b, int c = 1) {}
109 };
110
111 struct NoArgClass
112 {
NoArgClassNoArgClass113 NoArgClass() {}
114 };
115
116 struct VirualDestrClass
117 {
118 VirualDestrClass(int arg);
119 virtual ~VirualDestrClass();
120 };
121
122 struct ConstrWithCleanupsClass
123 {
124 ConstrWithCleanupsClass(const VirualDestrClass& cplx = VirualDestrClass(42));
125 };
126
127 // CHECK: test12
128 // CHECK-NEXT: DefaultArgClass useDefaultArg;
129 // CHECK-NEXT: DefaultArgClass overrideDefaultArg(1);
130 // CHECK-NEXT: DefaultArgClass(1, 2);
131 // CHECK-NEXT: DefaultArgClass(1, 2, 3);
132 // CHECK-NEXT: NoArgClass noArg;
133 // CHECK-NEXT: ConstrWithCleanupsClass cwcNoArg;
134 // CHECK-NEXT: ConstrWithCleanupsClass cwcOverrideArg(48);
135 // CHECK-NEXT: ConstrWithCleanupsClass cwcExplicitArg(VirualDestrClass(56));
test12()136 void test12() {
137 DefaultArgClass useDefaultArg;
138 DefaultArgClass overrideDefaultArg(1);
139 DefaultArgClass tempWithDefaultArg = DefaultArgClass(1, 2);
140 DefaultArgClass tempWithExplictArg = DefaultArgClass(1, 2, 3);
141 NoArgClass noArg;
142 ConstrWithCleanupsClass cwcNoArg;
143 ConstrWithCleanupsClass cwcOverrideArg(48);
144 ConstrWithCleanupsClass cwcExplicitArg(VirualDestrClass(56));
145 }
146
147 // CHECK: void test13() {
148 // CHECK: _Atomic(int) i;
149 // CHECK: __c11_atomic_init(&i, 0);
150 // CHECK: __c11_atomic_load(&i, 0);
151 // CHECK: }
test13()152 void test13() {
153 _Atomic(int) i;
154 __c11_atomic_init(&i, 0);
155 __c11_atomic_load(&i, 0);
156 }
157
158
159 // CHECK: void test14() {
160 // CHECK: struct X {
161 // CHECK: union {
162 // CHECK: int x;
163 // CHECK: } x;
164 // CHECK: };
165 // CHECK: }
test14()166 void test14() {
167 struct X { union { int x; } x; };
168 }
169
170
171 // CHECK: float test15() {
172 // CHECK: return __builtin_asinf(1.F);
173 // CHECK: }
174 // CHECK-NOT: extern "C"
test15()175 float test15() {
176 return __builtin_asinf(1.0F);
177 }
178
179 namespace PR18776 {
180 struct A {
181 operator void *();
182 explicit operator bool();
183 A operator&(A);
184 };
185
186 // CHECK: struct A
187 // CHECK-NEXT: {{^[ ]*operator}} void *();
188 // CHECK-NEXT: {{^[ ]*explicit}} operator bool();
189
190 void bar(void *);
191
foo()192 void foo() {
193 A a, b;
194 bar(a & b);
195 // CHECK: bar(a & b);
196 if (a & b)
197 // CHECK: if (a & b)
198 return;
199 }
200 };
201
202 namespace {
test(int i)203 void test(int i) {
204 switch (i) {
205 case 1:
206 // CHECK: {{\[\[clang::fallthrough\]\]}}
207 [[clang::fallthrough]];
208 case 2:
209 break;
210 }
211 }
212 }
213
214 namespace {
215 // CHECK: struct {{\[\[gnu::visibility\(\"hidden\"\)\]\]}} S;
216 struct [[gnu::visibility("hidden")]] S;
217 }
218
219 // CHECK: struct CXXFunctionalCastExprPrint {
220 // CHECK-NEXT: } fce = CXXFunctionalCastExprPrint{};
221 struct CXXFunctionalCastExprPrint {} fce = CXXFunctionalCastExprPrint{};
222
223 // CHECK: struct CXXTemporaryObjectExprPrint {
224 // CHECK-NEXT: CXXTemporaryObjectExprPrint();
225 // CHECK-NEXT: } toe = CXXTemporaryObjectExprPrint{};
226 struct CXXTemporaryObjectExprPrint { CXXTemporaryObjectExprPrint(); } toe = CXXTemporaryObjectExprPrint{};
227
228 namespace PR24872 {
229 // CHECK: template <typename T> struct Foo : T {
230 // CHECK: using T::operator-;
231 template <typename T> struct Foo : T {
232 using T::operator-;
233 };
234 }
235
236 namespace dont_crash_on_auto_vars {
237 struct T { enum E {X = 12ll }; };
238 struct S {
239 struct { int I; } ADecl;
240 static const auto Y = T::X;
241 };
242 //CHECK: static const auto Y = T::X;
243 constexpr auto var = T::X;
244 //CHECK: constexpr auto var = T::X;
245 }
246