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