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