Daniel Dunbar | a572887 | 2009-12-15 20:14:24 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify %s |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 2 | namespace A { |
| 3 | struct C { |
| 4 | static int cx; |
Douglas Gregor | 656de63 | 2009-03-11 23:52:16 +0000 | [diff] [blame] | 5 | |
| 6 | static int cx2; |
| 7 | |
| 8 | static int Ag1(); |
| 9 | static int Ag2(); |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 10 | }; |
| 11 | int ax; |
| 12 | void Af(); |
| 13 | } |
| 14 | |
| 15 | A:: ; // expected-error {{expected unqualified-id}} |
Jeffrey Yasskin | edc2877 | 2010-04-07 23:29:58 +0000 | [diff] [blame] | 16 | // FIXME: there is a member 'ax'; it's just not a class. |
| 17 | ::A::ax::undef ex3; // expected-error {{no member named 'ax'}} |
| 18 | A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}} |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 19 | |
Douglas Gregor | 656de63 | 2009-03-11 23:52:16 +0000 | [diff] [blame] | 20 | int A::C::Ag1() { return 0; } |
| 21 | |
Douglas Gregor | a3a8351 | 2009-04-01 23:51:29 +0000 | [diff] [blame] | 22 | static int A::C::Ag2() { return 0; } // expected-error{{'static' can}} |
Douglas Gregor | 656de63 | 2009-03-11 23:52:16 +0000 | [diff] [blame] | 23 | |
| 24 | int A::C::cx = 17; |
| 25 | |
| 26 | |
Douglas Gregor | a3a8351 | 2009-04-01 23:51:29 +0000 | [diff] [blame] | 27 | static int A::C::cx2 = 17; // expected-error{{'static' can}} |
Douglas Gregor | 656de63 | 2009-03-11 23:52:16 +0000 | [diff] [blame] | 28 | |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 29 | class C2 { |
Kaelyn Uhrain | 1055393 | 2011-10-10 18:01:37 +0000 | [diff] [blame] | 30 | void m(); // expected-note{{member declaration does not match because it is not const qualified}} |
Douglas Gregor | 584049d | 2008-12-15 23:53:10 +0000 | [diff] [blame] | 31 | |
Kaelyn Uhrain | 4d9d157 | 2011-08-04 17:40:00 +0000 | [diff] [blame] | 32 | void f(const int& parm); // expected-note{{type of 1st parameter of member declaration does not match definition ('const int &' vs 'int')}} |
Kaelyn Uhrain | 1055393 | 2011-10-10 18:01:37 +0000 | [diff] [blame] | 33 | void f(int) const; // expected-note{{member declaration does not match because it is const qualified}} |
Douglas Gregor | 584049d | 2008-12-15 23:53:10 +0000 | [diff] [blame] | 34 | void f(float); |
| 35 | |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 36 | int x; |
| 37 | }; |
| 38 | |
John McCall | 7c2342d | 2010-03-10 11:27:22 +0000 | [diff] [blame] | 39 | void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'C2'}} |
Douglas Gregor | 584049d | 2008-12-15 23:53:10 +0000 | [diff] [blame] | 40 | |
John McCall | 7c2342d | 2010-03-10 11:27:22 +0000 | [diff] [blame] | 41 | void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'C2'}} |
Douglas Gregor | 584049d | 2008-12-15 23:53:10 +0000 | [diff] [blame] | 42 | |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 43 | void C2::m() { |
| 44 | x = 0; |
| 45 | } |
| 46 | |
| 47 | namespace B { |
Richard Smith | a1c4f7c | 2012-04-13 04:07:40 +0000 | [diff] [blame] | 48 | void ::A::Af() {} // expected-error {{cannot define or redeclare 'Af' here because namespace 'B' does not enclose namespace 'A'}} |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 49 | } |
| 50 | |
| 51 | void f1() { |
Douglas Gregor | 584049d | 2008-12-15 23:53:10 +0000 | [diff] [blame] | 52 | void A::Af(); // expected-error {{definition or redeclaration of 'Af' not allowed inside a function}} |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 53 | } |
| 54 | |
| 55 | void f2() { |
| 56 | A:: ; // expected-error {{expected unqualified-id}} |
| 57 | A::C::undef = 0; // expected-error {{no member named 'undef'}} |
| 58 | ::A::C::cx = 0; |
| 59 | int x = ::A::ax = A::C::cx; |
| 60 | x = sizeof(A::C); |
| 61 | x = sizeof(::A::C::cx); |
| 62 | } |
| 63 | |
| 64 | A::C c1; |
| 65 | struct A::C c2; |
| 66 | struct S : public A::C {}; |
Douglas Gregor | 1eabb7d | 2010-03-31 23:17:41 +0000 | [diff] [blame] | 67 | struct A::undef; // expected-error {{no struct named 'undef' in namespace 'A'}} |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 68 | |
Argyrios Kyrtzidis | 5239304 | 2008-11-09 23:41:00 +0000 | [diff] [blame] | 69 | namespace A2 { |
| 70 | typedef int INT; |
| 71 | struct RC; |
Argyrios Kyrtzidis | 77407b8 | 2008-11-19 18:01:13 +0000 | [diff] [blame] | 72 | struct CC { |
| 73 | struct NC; |
| 74 | }; |
Argyrios Kyrtzidis | 5239304 | 2008-11-09 23:41:00 +0000 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | struct A2::RC { |
| 78 | INT x; |
| 79 | }; |
| 80 | |
Argyrios Kyrtzidis | 77407b8 | 2008-11-19 18:01:13 +0000 | [diff] [blame] | 81 | struct A2::CC::NC { |
| 82 | void m() {} |
| 83 | }; |
| 84 | |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 85 | void f3() { |
| 86 | N::x = 0; // expected-error {{use of undeclared identifier 'N'}} |
| 87 | int N; |
| 88 | N::x = 0; // expected-error {{expected a class or namespace}} |
| 89 | { int A; A::ax = 0; } |
Douglas Gregor | 3dde5a3 | 2008-12-16 06:37:47 +0000 | [diff] [blame] | 90 | { typedef int A; A::ax = 0; } // expected-error{{expected a class or namespace}} |
Argyrios Kyrtzidis | ef6e647 | 2008-11-08 17:17:31 +0000 | [diff] [blame] | 91 | { typedef A::C A; A::ax = 0; } // expected-error {{no member named 'ax'}} |
| 92 | { typedef A::C A; A::cx = 0; } |
| 93 | } |
Argyrios Kyrtzidis | 08b2c37 | 2008-11-19 15:22:16 +0000 | [diff] [blame] | 94 | |
| 95 | // make sure the following doesn't hit any asserts |
Richard Smith | 0576681 | 2012-08-18 00:55:03 +0000 | [diff] [blame] | 96 | void f4(undef::C); // expected-error {{use of undeclared identifier 'undef'}} |
Douglas Gregor | 584049d | 2008-12-15 23:53:10 +0000 | [diff] [blame] | 97 | |
| 98 | typedef void C2::f5(int); // expected-error{{typedef declarator cannot be qualified}} |
| 99 | |
| 100 | void f6(int A2::RC::x); // expected-error{{parameter declarator cannot be qualified}} |
| 101 | |
| 102 | int A2::RC::x; // expected-error{{non-static data member defined out-of-line}} |
| 103 | |
Chandler Carruth | 34fa294 | 2010-07-16 05:46:45 +0000 | [diff] [blame] | 104 | void A2::CC::NC::m(); // expected-error{{out-of-line declaration of a member must be a definition}} |
Douglas Gregor | 3dde5a3 | 2008-12-16 06:37:47 +0000 | [diff] [blame] | 105 | |
| 106 | |
| 107 | namespace E { |
| 108 | int X = 5; |
| 109 | |
| 110 | namespace Nested { |
| 111 | enum E { |
| 112 | X = 0 |
| 113 | }; |
| 114 | |
Kaelyn Uhrain | ef094a1 | 2012-06-07 23:57:08 +0000 | [diff] [blame] | 115 | void f() { |
Douglas Gregor | 3dde5a3 | 2008-12-16 06:37:47 +0000 | [diff] [blame] | 116 | return E::X; // expected-error{{expected a class or namespace}} |
| 117 | } |
| 118 | } |
| 119 | } |
Douglas Gregor | 70316a0 | 2008-12-26 15:00:45 +0000 | [diff] [blame] | 120 | |
| 121 | |
| 122 | class Operators { |
Kaelyn Uhrain | 1055393 | 2011-10-10 18:01:37 +0000 | [diff] [blame] | 123 | Operators operator+(const Operators&) const; // expected-note{{member declaration does not match because it is const qualified}} |
Douglas Gregor | 70316a0 | 2008-12-26 15:00:45 +0000 | [diff] [blame] | 124 | operator bool(); |
| 125 | }; |
| 126 | |
John McCall | 7c2342d | 2010-03-10 11:27:22 +0000 | [diff] [blame] | 127 | Operators Operators::operator+(const Operators&) { // expected-error{{out-of-line definition of 'operator+' does not match any declaration in 'Operators'}} |
Douglas Gregor | 70316a0 | 2008-12-26 15:00:45 +0000 | [diff] [blame] | 128 | Operators ops; |
| 129 | return ops; |
| 130 | } |
| 131 | |
| 132 | Operators Operators::operator+(const Operators&) const { |
| 133 | Operators ops; |
| 134 | return ops; |
| 135 | } |
| 136 | |
| 137 | Operators::operator bool() { |
| 138 | return true; |
| 139 | } |
Douglas Gregor | 4ce205f | 2009-02-06 17:46:57 +0000 | [diff] [blame] | 140 | |
| 141 | namespace A { |
Kaelyn Uhrain | 4d9d157 | 2011-08-04 17:40:00 +0000 | [diff] [blame] | 142 | void g(int&); // expected-note{{type of 1st parameter of member declaration does not match definition ('int &' vs 'const int &')}} |
Douglas Gregor | 4ce205f | 2009-02-06 17:46:57 +0000 | [diff] [blame] | 143 | } |
| 144 | |
Kaelyn Uhrain | ef094a1 | 2012-06-07 23:57:08 +0000 | [diff] [blame] | 145 | void A::f() {} // expected-error-re{{out-of-line definition of 'f' does not match any declaration in namespace 'A'$}} |
Douglas Gregor | 4ce205f | 2009-02-06 17:46:57 +0000 | [diff] [blame] | 146 | |
Douglas Gregor | 3f09327 | 2009-10-13 21:16:44 +0000 | [diff] [blame] | 147 | void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}} |
Douglas Gregor | 4ce205f | 2009-02-06 17:46:57 +0000 | [diff] [blame] | 148 | |
| 149 | struct Struct { }; |
| 150 | |
John McCall | 7c2342d | 2010-03-10 11:27:22 +0000 | [diff] [blame] | 151 | void Struct::f() { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'Struct'}} |
Douglas Gregor | 4ce205f | 2009-02-06 17:46:57 +0000 | [diff] [blame] | 152 | |
| 153 | void global_func(int); |
| 154 | void global_func2(int); |
| 155 | |
| 156 | namespace N { |
| 157 | void ::global_func(int) { } // expected-error{{definition or redeclaration of 'global_func' cannot name the global scope}} |
| 158 | |
| 159 | void f(); |
| 160 | // FIXME: if we move this to a separate definition of N, things break! |
| 161 | } |
Douglas Gregor | 7537945 | 2012-09-13 20:16:20 +0000 | [diff] [blame] | 162 | void ::global_func2(int) { } // expected-error{{extra qualification on member 'global_func2'}} |
Douglas Gregor | 4ce205f | 2009-02-06 17:46:57 +0000 | [diff] [blame] | 163 | |
| 164 | void N::f() { } // okay |
Douglas Gregor | 9fa14a5 | 2009-03-06 19:06:37 +0000 | [diff] [blame] | 165 | |
John McCall | 7c2342d | 2010-03-10 11:27:22 +0000 | [diff] [blame] | 166 | struct Y; // expected-note{{forward declaration of 'Y'}} |
Jeffrey Yasskin | 9ab1454 | 2010-04-08 16:38:48 +0000 | [diff] [blame] | 167 | Y::foo y; // expected-error{{incomplete type 'Y' named in nested name specifier}} |
Douglas Gregor | 4fdf1fa | 2009-03-11 16:48:53 +0000 | [diff] [blame] | 168 | |
Douglas Gregor | 9fa14a5 | 2009-03-06 19:06:37 +0000 | [diff] [blame] | 169 | X::X() : a(5) { } // expected-error{{use of undeclared identifier 'X'}} \ |
Anders Carlsson | a7b3521 | 2009-03-25 02:58:17 +0000 | [diff] [blame] | 170 | // expected-error{{C++ requires a type specifier for all declarations}} \ |
| 171 | // expected-error{{only constructors take base initializers}} |
Chris Lattner | c8e27cc | 2009-06-26 04:27:47 +0000 | [diff] [blame] | 172 | |
Argyrios Kyrtzidis | f37006b | 2009-07-21 06:43:26 +0000 | [diff] [blame] | 173 | struct foo_S { |
| 174 | static bool value; |
| 175 | }; |
| 176 | bool (foo_S::value); |
Chris Lattner | c8e27cc | 2009-06-26 04:27:47 +0000 | [diff] [blame] | 177 | |
| 178 | |
| 179 | namespace somens { |
John McCall | 220ccbf | 2010-01-13 00:25:19 +0000 | [diff] [blame] | 180 | struct a { }; // expected-note{{candidate constructor (the implicit copy constructor)}} |
Chris Lattner | c8e27cc | 2009-06-26 04:27:47 +0000 | [diff] [blame] | 181 | } |
| 182 | |
| 183 | template <typename T> |
| 184 | class foo { |
| 185 | }; |
| 186 | |
| 187 | |
Chris Lattner | 4664649 | 2009-12-07 01:36:53 +0000 | [diff] [blame] | 188 | // PR4452 / PR4451 |
| 189 | foo<somens:a> a2; // expected-error {{unexpected ':' in nested name specifier}} |
Chris Lattner | c8e27cc | 2009-06-26 04:27:47 +0000 | [diff] [blame] | 190 | |
Douglas Gregor | 7abfbdb | 2009-12-19 03:01:41 +0000 | [diff] [blame] | 191 | somens::a a3 = a2; // expected-error {{no viable conversion}} |
Chris Lattner | c8e27cc | 2009-06-26 04:27:47 +0000 | [diff] [blame] | 192 | |
John McCall | 1d7c528 | 2009-12-18 10:40:03 +0000 | [diff] [blame] | 193 | // typedefs and using declarations. |
| 194 | namespace test1 { |
| 195 | namespace ns { |
John McCall | 7002f4c | 2010-04-09 19:03:51 +0000 | [diff] [blame] | 196 | class Counter { public: static int count; }; |
John McCall | 1d7c528 | 2009-12-18 10:40:03 +0000 | [diff] [blame] | 197 | typedef Counter counter; |
| 198 | } |
| 199 | using ns::counter; |
Chris Lattner | c8e27cc | 2009-06-26 04:27:47 +0000 | [diff] [blame] | 200 | |
John McCall | 1d7c528 | 2009-12-18 10:40:03 +0000 | [diff] [blame] | 201 | class Test { |
| 202 | void test1() { |
| 203 | counter c; |
| 204 | c.count++; |
| 205 | counter::count++; |
| 206 | } |
| 207 | }; |
| 208 | } |
John McCall | 731ad84 | 2009-12-19 09:28:58 +0000 | [diff] [blame] | 209 | |
| 210 | // We still need to do lookup in the lexical scope, even if we push a |
| 211 | // non-lexical scope. |
| 212 | namespace test2 { |
| 213 | namespace ns { |
Sebastian Redl | 78a527a | 2010-01-26 18:52:33 +0000 | [diff] [blame] | 214 | extern int *count_ptr; |
John McCall | 731ad84 | 2009-12-19 09:28:58 +0000 | [diff] [blame] | 215 | } |
| 216 | namespace { |
| 217 | int count = 0; |
| 218 | } |
| 219 | |
| 220 | int *ns::count_ptr = &count; |
| 221 | } |
John McCall | 4c72d3e | 2010-02-08 19:26:07 +0000 | [diff] [blame] | 222 | |
| 223 | // PR6259, invalid case |
| 224 | namespace test3 { |
Jeffrey Yasskin | 9ab1454 | 2010-04-08 16:38:48 +0000 | [diff] [blame] | 225 | class A; // expected-note {{forward declaration}} |
John McCall | 4c72d3e | 2010-02-08 19:26:07 +0000 | [diff] [blame] | 226 | void foo(const char *path) { |
Jeffrey Yasskin | 9ab1454 | 2010-04-08 16:38:48 +0000 | [diff] [blame] | 227 | A::execute(path); // expected-error {{incomplete type 'test3::A' named in nested name specifier}} |
John McCall | 4c72d3e | 2010-02-08 19:26:07 +0000 | [diff] [blame] | 228 | } |
| 229 | } |
Douglas Gregor | 00b4b03 | 2010-05-14 04:53:42 +0000 | [diff] [blame] | 230 | |
| 231 | namespace PR7133 { |
| 232 | namespace A { |
| 233 | class Foo; |
| 234 | } |
| 235 | |
| 236 | namespace A { |
| 237 | namespace B { |
| 238 | bool foo(Foo &); |
| 239 | } |
| 240 | } |
| 241 | |
| 242 | bool A::B::foo(Foo &) { |
| 243 | return false; |
| 244 | } |
| 245 | } |
Francois Pichet | c71d8eb | 2010-10-01 21:19:28 +0000 | [diff] [blame] | 246 | |
| 247 | class CLASS { |
Douglas Gregor | 7537945 | 2012-09-13 20:16:20 +0000 | [diff] [blame] | 248 | void CLASS::foo2(); // expected-error {{extra qualification on member 'foo2'}} |
Francois Pichet | c71d8eb | 2010-10-01 21:19:28 +0000 | [diff] [blame] | 249 | }; |
Douglas Gregor | 922fff2 | 2010-10-13 22:19:53 +0000 | [diff] [blame] | 250 | |
| 251 | namespace PR8159 { |
| 252 | class B { }; |
| 253 | |
| 254 | class A { |
Douglas Gregor | 7537945 | 2012-09-13 20:16:20 +0000 | [diff] [blame] | 255 | int A::a; // expected-error{{extra qualification on member 'a'}} |
| 256 | static int A::b; // expected-error{{extra qualification on member 'b'}} |
Douglas Gregor | 922fff2 | 2010-10-13 22:19:53 +0000 | [diff] [blame] | 257 | int ::c; // expected-error{{non-friend class member 'c' cannot have a qualified name}} |
| 258 | }; |
| 259 | } |
Argyrios Kyrtzidis | 1de34dd | 2011-02-05 05:54:49 +0000 | [diff] [blame] | 260 | |
| 261 | namespace rdar7980179 { |
| 262 | class A { void f0(); }; // expected-note {{previous}} |
John McCall | 239cad7 | 2011-06-27 21:23:26 +0000 | [diff] [blame] | 263 | int A::f0() {} // expected-error {{out-of-line definition of 'rdar7980179::A::f0' differs from the declaration in the return type}} |
Argyrios Kyrtzidis | 1de34dd | 2011-02-05 05:54:49 +0000 | [diff] [blame] | 264 | } |
Douglas Gregor | fa0b48f | 2011-02-24 02:37:39 +0000 | [diff] [blame] | 265 | |
| 266 | namespace alias = A; |
| 267 | double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}} |
Argyrios Kyrtzidis | a7bf7bb | 2011-06-24 19:59:27 +0000 | [diff] [blame] | 268 | |
| 269 | // http://llvm.org/PR10109 |
| 270 | namespace PR10109 { |
| 271 | template<typename T> |
| 272 | struct A { |
| 273 | protected: |
| 274 | struct B; |
| 275 | struct B::C; // expected-error {{requires a template parameter list}} \ |
Douglas Gregor | 42acead | 2012-03-17 23:06:31 +0000 | [diff] [blame] | 276 | // expected-error {{no struct named 'C'}} \ |
| 277 | // expected-error{{non-friend class member 'C' cannot have a qualified name}} |
Argyrios Kyrtzidis | a7bf7bb | 2011-06-24 19:59:27 +0000 | [diff] [blame] | 278 | }; |
| 279 | |
| 280 | template<typename T> |
| 281 | struct A2 { |
| 282 | protected: |
| 283 | struct B; |
| 284 | }; |
| 285 | template <typename T> |
| 286 | struct A2<T>::B::C; // expected-error {{no struct named 'C'}} |
| 287 | } |
Kaelyn Uhrain | 8d3607b | 2012-06-06 20:54:51 +0000 | [diff] [blame] | 288 | |
| 289 | namespace PR13033 { |
| 290 | namespace NS { |
| 291 | int a; // expected-note {{'NS::a' declared here}} |
| 292 | int longer_b; //expected-note {{'NS::longer_b' declared here}} |
| 293 | } |
| 294 | |
| 295 | // Suggest adding a namespace qualifier to both variable names even though one |
| 296 | // is only a single character long. |
| 297 | int foobar = a + longer_b; // expected-error {{use of undeclared identifier 'a'; did you mean 'NS::a'?}} \ |
| 298 | // expected-error {{use of undeclared identifier 'longer_b'; did you mean 'NS::longer_b'?}} |
| 299 | } |