1 // RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -pedantic -fcxx-exceptions -fexceptions %s 2 3 const char const *x10; // expected-warning {{duplicate 'const' declaration specifier}} 4 5 int x(*g); // expected-error {{use of undeclared identifier 'g'}} 6 7 struct Type { 8 int Type; 9 }; 10 11 // rdar://8365458 12 // rdar://9132143 13 typedef char bool; // expected-error {{redeclaration of C++ built-in type 'bool'}} 14 15 // PR4451 - We should recover well from the typo of '::' as ':' in a2. 16 namespace y { 17 struct a { }; 18 typedef int b; 19 } 20 21 y::a a1; 22 y:a a2; // expected-error {{unexpected ':' in nested name specifier}} 23 y::a a3 = a2; 24 25 // Some valid colons: 26 void foo() { 27 y: // label 28 y::a s; 29 30 int a = 4; 31 a = a ? a : a+1; 32 } 33 34 struct b : y::a {}; 35 36 template <typename T> 37 class someclass { 38 39 int bar() { 40 T *P; 41 return 1 ? P->x : P->y; 42 } 43 }; 44 45 class asm_class_test { 46 void foo() __asm__("baz"); 47 }; 48 49 enum { fooenum = 1, }; // expected-warning {{commas at the end of enumerator lists are a C++11 extension}} 50 51 struct a { 52 int Type : fooenum; 53 }; 54 55 void test(struct Type *P) { 56 int Type; 57 Type = 1 ? P->Type : Type; 58 59 Type = (y:b) 4; // expected-error {{unexpected ':' in nested name specifier}} 60 Type = 1 ? ( 61 (y:b) // expected-error {{unexpected ':' in nested name specifier}} 62 4) : 5; 63 } 64 65 struct test4 { 66 int x // expected-error {{expected ';' at end of declaration list}} 67 int y; 68 int z // expected-error {{expected ';' at end of declaration list}} 69 }; 70 71 // Make sure we know these are legitimate commas and not typos for ';'. 72 namespace Commas { 73 struct S { 74 static int a; 75 int c, 76 operator()(); 77 }; 78 79 int global1, 80 __attribute__(()) global2, 81 (global5), 82 *global6, 83 &global7 = global1, 84 &&global8 = static_cast<int&&>(global1), // expected-warning 2{{rvalue reference}} 85 S::a, 86 global9, 87 global10 = 0, 88 global11 == 0, // expected-error {{did you mean '='}} 89 global12 __attribute__(()), 90 global13(0), 91 global14[2], 92 global15; 93 94 void g() { 95 static int a, 96 b __asm__("ebx"), // expected-error {{expected ';' at end of declaration}} 97 Statics:return; 98 } 99 } 100 101 // PR5825 102 struct test5 {}; 103 ::new(static_cast<void*>(0)) test5; // expected-error {{expected unqualified-id}} 104 105 106 // PR6782 107 template<class T> 108 class Class1; 109 110 class Class2 { 111 } // expected-error {{expected ';' after class}} 112 113 typedef Class1<Class2> Type1; 114 115 // rdar : // 8307865 116 struct CodeCompleteConsumer { 117 }; 118 119 void CodeCompleteConsumer::() { // expected-error {{xpected unqualified-id}} 120 } 121 122 ; 123 124 // PR4111 125 void f(sqrgl); // expected-error {{unknown type name 'sqrgl'}} 126 127 // PR9903 128 struct S { 129 typedef void a() { }; // expected-error {{function definition declared 'typedef'}} 130 typedef void c() try { } catch(...) { } // expected-error {{function definition declared 'typedef'}} 131 int n, m; 132 typedef S() : n(1), m(2) { } // expected-error {{function definition declared 'typedef'}} 133 }; 134 135 136 namespace TestIsValidAfterTypeSpecifier { 137 struct s {} v; 138 139 namespace a { 140 struct s operator++(struct s a) 141 { return a; } 142 } 143 144 namespace b { 145 // The newline after s should make no difference. 146 struct s 147 operator++(struct s a) 148 { return a; } 149 } 150 151 struct X { 152 struct s 153 friend f(); 154 struct s 155 virtual f(); 156 }; 157 158 struct s 159 &r0 = v; 160 struct s 161 bitand r2 = v; 162 163 } 164 165 struct DIE { 166 void foo() {} 167 }; 168 169 void test (DIE die, DIE *Die, DIE INT, DIE *FLOAT) { 170 DIE.foo(); // expected-error {{cannot use dot operator on a type}} 171 die.foo(); 172 173 DIE->foo(); // expected-error {{cannot use arrow operator on a type}} 174 Die->foo(); 175 176 int.foo(); // expected-error {{cannot use dot operator on a type}} 177 INT.foo(); 178 179 float->foo(); // expected-error {{cannot use arrow operator on a type}} 180 FLOAT->foo(); 181 } 182 183 namespace PR15017 { 184 template<typename T = struct X { int i; }> struct S {}; // expected-error {{'PR15017::X' can not be defined in a type specifier}} 185 } 186 187 // Ensure we produce at least some diagnostic for attributes in C++98. 188 [[]] struct S; // expected-error 2{{}} 189 190 namespace test7 { 191 struct Foo { 192 void a(); 193 void b(); 194 }; 195 196 void Foo:: 197 // Comment! 198 a() {} 199 200 201 void Foo:: // expected-error {{expected unqualified-id}} 202 // Comment! 203 } 204 205 void test8() { 206 struct {} o; 207 // This used to crash. 208 (&o)->(); // expected-error{{expected unqualified-id}} 209 } 210 211 namespace PR5066 { 212 template<typename T> struct X {}; 213 X<int N> x; // expected-error {{type-id cannot have a name}} 214 215 using T = int (*T)(); // expected-error {{type-id cannot have a name}} expected-warning {{C++11}} 216 } 217 218 namespace PR17255 { 219 void foo() { 220 typename A::template B<>; // expected-error {{use of undeclared identifier 'A'}} \ 221 // expected-error {{expected a qualified name after 'typename'}} \ 222 // expected-warning {{'template' keyword outside of a template}} 223 } 224 } 225 226 namespace PR17567 { 227 struct Foobar { // expected-note 2{{declared here}} 228 FooBar(); // expected-error {{missing return type for function 'FooBar'; did you mean the constructor name 'Foobar'?}} 229 ~FooBar(); // expected-error {{expected the class name after '~' to name a destructor}} 230 }; 231 FooBar::FooBar() {} // expected-error {{undeclared}} expected-error {{missing return type}} 232 FooBar::~FooBar() {} // expected-error {{undeclared}} expected-error {{expected the class name}} 233 } 234 235 // PR8380 236 extern "" // expected-error {{unknown linkage language}} 237 test6a { ;// expected-error {{C++ requires a type specifier for all declarations}} \ 238 // expected-error {{expected ';' after top level declarator}} 239 240 int test6b; 241