1 // RUN: %clang_cc1 -fspell-checking-limit 0 -verify -Wno-c++11-extensions %s 2 3 namespace PR21817{ 4 int a(-rsing[2]); // expected-error {{undeclared identifier 'rsing'; did you mean 'using'?}} 5 // expected-error@-1 {{expected expression}} 6 } 7 8 struct errc { 9 int v_; 10 operator int() const {return v_;} 11 }; 12 13 class error_condition 14 { 15 int _val_; 16 public: 17 error_condition() : _val_(0) {} 18 19 error_condition(int _val) 20 : _val_(_val) {} 21 22 template <class E> 23 error_condition(E _e) { 24 // make_error_condition must not be typo corrected to error_condition 25 // even though the first declaration of make_error_condition has not 26 // yet been encountered. This was a bug in the first version of the type 27 // name typo correction patch that wasn't noticed until building LLVM with 28 // Clang failed. 29 *this = make_error_condition(_e); 30 } 31 32 }; 33 34 inline error_condition make_error_condition(errc _e) { 35 return error_condition(static_cast<int>(_e)); 36 } 37 38 39 // Prior to the introduction of a callback object to further filter possible 40 // typo corrections, this example would not trigger a suggestion as "base_type" 41 // is a closer match to "basetype" than is "BaseType" but "base_type" does not 42 // refer to a base class or non-static data member. 43 struct BaseType { }; 44 struct Derived : public BaseType { // expected-note {{base class 'BaseType' specified here}} 45 static int base_type; // expected-note {{'base_type' declared here}} 46 Derived() : basetype() {} // expected-error{{initializer 'basetype' does not name a non-static data member or base class; did you mean the base class 'BaseType'?}} 47 }; 48 49 // Test the improvement from passing a callback object to CorrectTypo in 50 // the helper function LookupMemberExprInRecord. 51 int get_type(struct Derived *st) { 52 return st->Base_Type; // expected-error{{no member named 'Base_Type' in 'Derived'; did you mean 'base_type'?}} 53 } 54 55 // In this example, somename should not be corrected to the cached correction 56 // "some_name" since "some_name" is a class and a namespace name is needed. 57 class some_name {}; // expected-note {{'some_name' declared here}} 58 somename Foo; // expected-error {{unknown type name 'somename'; did you mean 'some_name'?}} 59 namespace SomeName {} // expected-note {{namespace 'SomeName' defined here}} 60 using namespace somename; // expected-error {{no namespace named 'somename'; did you mean 'SomeName'?}} 61 62 63 // Without the callback object, CorrectTypo would choose "field1" as the 64 // correction for "fielda" as it is closer than "FieldA", but that correction 65 // would be later discarded by the caller and no suggestion would be given. 66 struct st { 67 struct { 68 int field1; 69 }; 70 double FieldA; // expected-note{{'FieldA' declared here}} 71 }; 72 st var = { .fielda = 0.0 }; // expected-error{{field designator 'fielda' does not refer to any field in type 'st'; did you mean 'FieldA'?}} 73 74 // Test the improvement from passing a callback object to CorrectTypo in 75 // Sema::BuildCXXNestedNameSpecifier. And also for the improvement by doing 76 // so in Sema::getTypeName. 77 typedef char* another_str; // expected-note{{'another_str' declared here}} 78 namespace AnotherStd { // expected-note{{'AnotherStd' declared here}} 79 class string {}; 80 } 81 another_std::string str; // expected-error{{use of undeclared identifier 'another_std'; did you mean 'AnotherStd'?}} 82 another_str *cstr = new AnotherStr; // expected-error{{unknown type name 'AnotherStr'; did you mean 'another_str'?}} 83 84 // Test the improvement from passing a callback object to CorrectTypo in 85 // Sema::ActOnSizeofParameterPackExpr. 86 char* TireNames; 87 template<typename ...TypeNames> struct count { // expected-note{{parameter pack 'TypeNames' declared here}} 88 static const unsigned value = sizeof...(TyreNames); // expected-error{{'TyreNames' does not refer to the name of a parameter pack; did you mean 'TypeNames'?}} 89 }; 90 91 // Test the typo-correction callback in Sema::DiagnoseUnknownTypeName. 92 namespace unknown_type_test { 93 class StreamOut {}; // expected-note 2 {{'StreamOut' declared here}} 94 long stream_count; // expected-note 2 {{'stream_count' declared here}} 95 }; 96 unknown_type_test::stream_out out; // expected-error{{no type named 'stream_out' in namespace 'unknown_type_test'; did you mean 'StreamOut'?}} 97 98 // Demonstrate a case where using only the cached value returns the wrong thing 99 // when the cached value was the result of a previous callback object that only 100 // accepts a subset of the current callback object. 101 namespace cache_invalidation_test { 102 using namespace unknown_type_test; 103 void bar(long i); 104 void before_caching_classname() { 105 bar((stream_out)); // expected-error{{use of undeclared identifier 'stream_out'; did you mean 'stream_count'?}} 106 } 107 stream_out out; // expected-error{{unknown type name 'stream_out'; did you mean 'StreamOut'?}} 108 void after_caching_classname() { 109 bar((stream_out)); // expected-error{{use of undeclared identifier 'stream_out'; did you mean 'stream_count'?}} 110 } 111 } 112 113 // Test the typo-correction callback in Sema::DiagnoseInvalidRedeclaration. 114 struct BaseDecl { 115 void add_in(int i); 116 }; 117 struct TestRedecl : public BaseDecl { 118 void add_it(int i); // expected-note{{'add_it' declared here}} 119 }; 120 void TestRedecl::add_in(int i) {} // expected-error{{out-of-line definition of 'add_in' does not match any declaration in 'TestRedecl'; did you mean 'add_it'?}} 121 122 // Test the improved typo correction for the Parser::ParseCastExpr => 123 // Sema::ActOnIdExpression => Sema::DiagnoseEmptyLookup call path. 124 class SomeNetMessage; // expected-note 2{{'SomeNetMessage'}} 125 class Message {}; 126 void foo(Message&); 127 void foo(SomeNetMessage&); 128 void doit(void *data) { 129 Message somenetmsg; // expected-note{{'somenetmsg' declared here}} 130 foo(somenetmessage); // expected-error{{use of undeclared identifier 'somenetmessage'; did you mean 'somenetmsg'?}} 131 foo((somenetmessage)data); // expected-error{{unknown type name 'somenetmessage'; did you mean 'SomeNetMessage'?}} expected-error{{incomplete type}} 132 } 133 134 // Test the typo-correction callback in BuildRecoveryCallExpr. 135 // Solves the main issue in PR 9320 of suggesting corrections that take the 136 // wrong number of arguments. 137 void revoke(const char*); // expected-note 2{{'revoke' declared here}} 138 void Test() { 139 Invoke(); // expected-error{{use of undeclared identifier 'Invoke'}} 140 Invoke("foo"); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'revoke'?}} 141 Invoke("foo", "bar"); // expected-error{{use of undeclared identifier 'Invoke'}} 142 } 143 void Test2(void (*invoke)(const char *, int)) { // expected-note{{'invoke' declared here}} 144 Invoke(); // expected-error{{use of undeclared identifier 'Invoke'}} 145 Invoke("foo"); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'revoke'?}} 146 Invoke("foo", 7); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'invoke'?}} 147 Invoke("foo", 7, 22); // expected-error{{use of undeclared identifier 'Invoke'}} 148 } 149 150 void provoke(const char *x, bool y=false) {} // expected-note 2{{'provoke' declared here}} 151 void Test3() { 152 Provoke(); // expected-error{{use of undeclared identifier 'Provoke'}} 153 Provoke("foo"); // expected-error{{use of undeclared identifier 'Provoke'; did you mean 'provoke'?}} 154 Provoke("foo", true); // expected-error{{use of undeclared identifier 'Provoke'; did you mean 'provoke'?}} 155 Provoke("foo", 7, 22); // expected-error{{use of undeclared identifier 'Provoke'}} 156 } 157 158 // PR 11737 - Don't try to typo-correct the implicit 'begin' and 'end' in a 159 // C++11 for-range statement. 160 struct R {}; 161 bool begun(R); 162 void RangeTest() { 163 for (auto b : R()) {} // expected-error {{invalid range expression of type 'R'}} 164 } 165 166 // PR 12019 - Avoid infinite mutual recursion in DiagnoseInvalidRedeclaration 167 // by not trying to typo-correct a method redeclaration to declarations not 168 // in the current record. 169 class Parent { 170 void set_types(int index, int value); 171 void add_types(int value); 172 }; 173 class Child: public Parent {}; 174 void Child::add_types(int value) {} // expected-error{{out-of-line definition of 'add_types' does not match any declaration in 'Child'}} 175 176 // Fix the callback based filtering of typo corrections within 177 // Sema::ActOnIdExpression by Parser::ParseCastExpression to allow type names as 178 // potential corrections for template arguments. 179 namespace clash { 180 class ConstructExpr {}; // expected-note 2{{'clash::ConstructExpr' declared here}} 181 } 182 class ClashTool { 183 bool HaveConstructExpr(); 184 template <class T> T* getExprAs(); 185 186 void test() { 187 ConstructExpr *expr = // expected-error{{unknown type name 'ConstructExpr'; did you mean 'clash::ConstructExpr'?}} 188 getExprAs<ConstructExpr>(); // expected-error{{unknown type name 'ConstructExpr'; did you mean 'clash::ConstructExpr'?}} 189 } 190 }; 191 192 namespace test1 { 193 struct S { 194 struct Foobar *f; // expected-note{{'Foobar' declared here}} 195 }; 196 test1::FooBar *b; // expected-error{{no type named 'FooBar' in namespace 'test1'; did you mean 'Foobar'?}} 197 } 198 199 namespace ImplicitInt { 200 void f(int, unsinged); // expected-error{{did you mean 'unsigned'}} 201 struct S { 202 unsinged : 4; // expected-error{{did you mean 'unsigned'}} 203 }; 204 } 205 206 namespace PR13051 { 207 template<typename T> struct S { 208 template<typename U> void f(); 209 operator bool() const; 210 }; 211 212 void foo(); // expected-note{{'foo' declared here}} 213 void g(void(*)()); // expected-note{{candidate function not viable}} 214 void g(bool(S<int>::*)() const); // expected-note{{candidate function not viable}} 215 216 void test() { 217 g(&S<int>::tempalte f<int>); // expected-error{{did you mean 'template'?}} \ 218 // expected-error{{no matching function for call to 'g'}} 219 g(&S<int>::opeartor bool); // expected-error{{did you mean 'operator'?}} 220 g(&S<int>::foo); // expected-error{{no member named 'foo' in 'PR13051::S<int>'; did you mean simply 'foo'?}} 221 } 222 } 223 224 inf f(doulbe); // expected-error{{'int'}} expected-error{{'double'}} 225 226 namespace PR6325 { 227 class foo { }; // expected-note{{'foo' declared here}} 228 // Note that for this example (pulled from the PR), if keywords are not excluded 229 // as correction candidates then no suggestion would be given; correcting 230 // 'boo' to 'bool' is the same edit distance as correcting 'boo' to 'foo'. 231 class bar : boo { }; // expected-error{{unknown class name 'boo'; did you mean 'foo'?}} 232 } 233 234 namespace outer { 235 void somefunc(); // expected-note{{'::outer::somefunc' declared here}} 236 void somefunc(int, int); // expected-note{{'::outer::somefunc' declared here}} 237 238 namespace inner { 239 void somefunc(int) { 240 someFunc(); // expected-error{{use of undeclared identifier 'someFunc'; did you mean '::outer::somefunc'?}} 241 someFunc(1, 2); // expected-error{{use of undeclared identifier 'someFunc'; did you mean '::outer::somefunc'?}} 242 } 243 } 244 } 245 246 namespace b6956809_test1 { 247 struct A {}; 248 struct B {}; 249 250 struct S1 { 251 void method(A*); // no note here 252 void method(B*); // expected-note{{'method' declared here}} 253 }; 254 255 void test1() { 256 B b; 257 S1 s; 258 s.methodd(&b); // expected-error{{no member named 'methodd' in 'b6956809_test1::S1'; did you mean 'method'}} 259 } 260 261 struct S2 { 262 S2(); 263 void method(A*) const; 264 private: 265 void method(B*); 266 }; 267 268 void test2() { 269 B b; 270 const S2 s; 271 s.methodd(&b); // expected-error-re{{no member named 'methodd' in 'b6956809_test1::S2'{{$}}}} 272 } 273 } 274 275 namespace b6956809_test2 { 276 template<typename T> struct Err { typename T::error n; }; // expected-error{{type 'void *' cannot be used prior to '::' because it has no members}} 277 struct S { 278 template<typename T> typename Err<T>::type method(T); // expected-note{{in instantiation of template class 'b6956809_test2::Err<void *>' requested here}} 279 template<typename T> int method(T *); // expected-note{{'method' declared here}} 280 }; 281 282 void test() { 283 S s; 284 int k = s.methodd((void*)0); // expected-error{{no member named 'methodd' in 'b6956809_test2::S'; did you mean 'method'?}} expected-note{{while substituting deduced template arguments into function template 'method' [with T = void *]}} 285 } 286 } 287 288 namespace PR12951 { 289 // If there are two corrections that have the same identifier and edit distance 290 // and only differ by their namespaces, don't suggest either as a correction 291 // since both are equally likely corrections. 292 namespace foobar { struct Thing {}; } 293 namespace bazquux { struct Thing {}; } 294 void f() { Thing t; } // expected-error{{unknown type name 'Thing'}} 295 } 296 297 namespace bogus_keyword_suggestion { 298 void test() { 299 status = "OK"; // expected-error-re {{use of undeclared identifier 'status'{{$}}}} 300 return status; // expected-error-re {{use of undeclared identifier 'status'{{$}}}} 301 } 302 } 303 304 namespace PR13387 { 305 struct A { 306 void CreateFoo(float, float); 307 void CreateBar(float, float); 308 }; 309 struct B : A { 310 using A::CreateFoo; 311 void CreateFoo(int, int); // expected-note {{'CreateFoo' declared here}} 312 }; 313 void f(B &x) { 314 x.Createfoo(0,0); // expected-error {{no member named 'Createfoo' in 'PR13387::B'; did you mean 'CreateFoo'?}} 315 } 316 } 317 318 struct DataStruct {void foo();}; 319 struct T { 320 DataStruct data_struct; 321 void f(); 322 }; 323 // should be void T::f(); 324 void f() { 325 data_struct->foo(); // expected-error-re{{use of undeclared identifier 'data_struct'{{$}}}} 326 } 327 328 namespace PR12287 { 329 class zif { 330 void nab(int); 331 }; 332 void nab(); // expected-note{{'::PR12287::nab' declared here}} 333 void zif::nab(int) { 334 nab(); // expected-error{{too few arguments to function call, expected 1, have 0; did you mean '::PR12287::nab'?}} 335 } 336 } 337 338 namespace TemplateFunction { 339 template <class T> 340 void A(T) { } // expected-note {{'::TemplateFunction::A' declared here}} 341 342 template <class T> 343 void B(T) { } // expected-note {{'::TemplateFunction::B' declared here}} 344 345 class Foo { 346 public: 347 void A(int, int) {} 348 void B() {} 349 }; 350 351 void test(Foo F, int num) { 352 F.A(num); // expected-error {{too few arguments to function call, expected 2, have 1; did you mean '::TemplateFunction::A'?}} 353 F.B(num); // expected-error {{too many arguments to function call, expected 0, have 1; did you mean '::TemplateFunction::B'?}} 354 } 355 } 356 namespace using_suggestion_val_dropped_specifier { 357 void FFF() {} // expected-note {{'::using_suggestion_val_dropped_specifier::FFF' declared here}} 358 namespace N { } 359 using N::FFF; // expected-error {{no member named 'FFF' in namespace 'using_suggestion_val_dropped_specifier::N'; did you mean '::using_suggestion_val_dropped_specifier::FFF'?}} 360 } 361 362 namespace class_member_typo_corrections { 363 class Outer { 364 public: 365 class Inner {}; // expected-note {{'Outer::Inner' declared here}} 366 Inner MyMethod(Inner arg); 367 }; 368 369 Inner Outer::MyMethod(Inner arg) { // expected-error {{unknown type name 'Inner'; did you mean 'Outer::Inner'?}} 370 return Inner(); 371 } 372 373 class Result { 374 public: 375 enum ResultType { 376 ENTITY, // expected-note {{'Result::ENTITY' declared here}} 377 PREDICATE, // expected-note {{'Result::PREDICATE' declared here}} 378 LITERAL // expected-note {{'Result::LITERAL' declared here}} 379 }; 380 381 ResultType type(); 382 }; 383 384 void test() { 385 Result result_cell; 386 switch (result_cell.type()) { 387 case ENTITY: // expected-error {{use of undeclared identifier 'ENTITY'; did you mean 'Result::ENTITY'?}} 388 case LITERAL: // expected-error {{use of undeclared identifier 'LITERAL'; did you mean 'Result::LITERAL'?}} 389 case PREDICAT: // expected-error {{use of undeclared identifier 'PREDICAT'; did you mean 'Result::PREDICATE'?}} 390 break; 391 } 392 } 393 394 class Figure { 395 enum ResultType { 396 SQUARE, 397 TRIANGLE, 398 CIRCLE 399 }; 400 401 public: 402 ResultType type(); 403 }; 404 405 void testAccess() { 406 Figure obj; 407 switch (obj.type()) { // expected-warning {{enumeration values 'SQUARE', 'TRIANGLE', and 'CIRCLE' not handled in switch}} 408 case SQUARE: // expected-error-re {{use of undeclared identifier 'SQUARE'{{$}}}} 409 case TRIANGLE: // expected-error-re {{use of undeclared identifier 'TRIANGLE'{{$}}}} 410 case CIRCE: // expected-error-re {{use of undeclared identifier 'CIRCE'{{$}}}} 411 break; 412 } 413 } 414 } 415 416 long readline(const char *, char *, unsigned long); 417 void assign_to_unknown_var() { 418 deadline_ = 1; // expected-error-re {{use of undeclared identifier 'deadline_'{{$}}}} 419 } 420 421 namespace no_ns_before_dot { 422 namespace re2 {} 423 void test() { 424 req.set_check(false); // expected-error-re {{use of undeclared identifier 'req'{{$}}}} 425 } 426 } 427 428 namespace PR17394 { 429 class A { 430 protected: 431 long zzzzzzzzzz; 432 }; 433 class B : private A {}; 434 B zzzzzzzzzy<>; // expected-error {{expected ';' after top level declarator}}{} 435 } 436 437 namespace correct_fields_in_member_funcs { 438 struct S { 439 int my_member; // expected-note {{'my_member' declared here}} 440 void f() { my_menber = 1; } // expected-error {{use of undeclared identifier 'my_menber'; did you mean 'my_member'?}} 441 }; 442 } 443 444 namespace PR17019 { 445 template<class F> 446 struct evil { 447 evil(F de) { // expected-note {{'de' declared here}} 448 de_; // expected-error {{use of undeclared identifier 'de_'; did you mean 'de'?}} \ 449 // expected-warning {{expression result unused}} 450 } 451 ~evil() { 452 de_->bar() // expected-error {{use of undeclared identifier 'de_'}} 453 } 454 }; 455 456 void meow() { 457 evil<int> Q(0); // expected-note {{in instantiation of member function}} 458 } 459 } 460 461 namespace fix_class_name_qualifier { 462 class MessageHeaders {}; 463 class MessageUtils { 464 public: 465 static void ParseMessageHeaders(int, int); // expected-note {{'MessageUtils::ParseMessageHeaders' declared here}} 466 }; 467 468 void test() { 469 // No, we didn't mean to call MessageHeaders::MessageHeaders. 470 MessageHeaders::ParseMessageHeaders(5, 4); // expected-error {{no member named 'ParseMessageHeaders' in 'fix_class_name_qualifier::MessageHeaders'; did you mean 'MessageUtils::ParseMessageHeaders'?}} 471 } 472 } 473 474 namespace PR18213 { // expected-note {{'PR18213' declared here}} 475 struct WrapperInfo { 476 int i; 477 }; 478 479 template <typename T> struct Wrappable { 480 static WrapperInfo kWrapperInfo; 481 }; 482 483 // Note the space before "::PR18213" is intended and needed, as it highlights 484 // the actual typo, which is the leading "::". 485 // TODO: Suggest removing the "::" from "::PR18213" (the right correction) 486 // instead of incorrectly suggesting dropping "PR18213::WrapperInfo::". 487 template <> 488 PR18213::WrapperInfo ::PR18213::Wrappable<int>::kWrapperInfo = { 0 }; // expected-error {{no member named 'PR18213' in 'PR18213::WrapperInfo'; did you mean simply 'PR18213'?}} \ 489 // expected-error {{C++ requires a type specifier for all declarations}} 490 } 491 492 namespace PR18651 { 493 struct { 494 int x; 495 } a, b; 496 497 int y = x; // expected-error-re {{use of undeclared identifier 'x'{{$}}}} 498 } 499 500 namespace PR18685 { 501 template <class C, int I, int J> 502 class SetVector { 503 public: 504 SetVector() {} 505 }; 506 507 template <class C, int I> 508 class SmallSetVector : public SetVector<C, I, 8> {}; 509 510 class foo {}; 511 SmallSetVector<foo*, 2> fooSet; 512 } 513 514 PR18685::BitVector Map; // expected-error-re {{no type named 'BitVector' in namespace 'PR18685'{{$}}}} 515 516 namespace shadowed_template { 517 template <typename T> class Fizbin {}; // expected-note {{'::shadowed_template::Fizbin' declared here}} 518 class Baz { 519 int Fizbin(); 520 // TODO: Teach the parser to recover from the typo correction instead of 521 // continuing to treat the template name as an implicit-int declaration. 522 Fizbin<int> qux; // expected-error {{unknown type name 'Fizbin'; did you mean '::shadowed_template::Fizbin'?}} \ 523 // expected-error {{expected member name or ';' after declaration specifiers}} 524 }; 525 } 526 527 namespace PR18852 { 528 void func() { 529 struct foo { 530 void bar() {} 531 }; 532 bar(); // expected-error-re {{use of undeclared identifier 'bar'{{$}}}} 533 } 534 535 class Thread { 536 public: 537 void Start(); 538 static void Stop(); // expected-note {{'Thread::Stop' declared here}} 539 }; 540 541 class Manager { 542 public: 543 void Start(int); // expected-note {{'Start' declared here}} 544 void Stop(int); // expected-note {{'Stop' declared here}} 545 }; 546 547 void test(Manager *m) { 548 // Don't suggest Thread::Start as a correction just because it has the same 549 // (unqualified) name and accepts the right number of args; this is a method 550 // call on an object in an unrelated class. 551 m->Start(); // expected-error-re {{too few arguments to function call, expected 1, have 0{{$}}}} 552 m->Stop(); // expected-error-re {{too few arguments to function call, expected 1, have 0{{$}}}} 553 Stop(); // expected-error {{use of undeclared identifier 'Stop'; did you mean 'Thread::Stop'?}} 554 } 555 556 } 557 558 namespace std { 559 class bernoulli_distribution { 560 public: 561 double p() const; 562 }; 563 } 564 void test() { 565 // Make sure that typo correction doesn't suggest changing 'p' to 566 // 'std::bernoulli_distribution::p' as that is most likely wrong. 567 if (p) // expected-error-re {{use of undeclared identifier 'p'{{$}}}} 568 return; 569 } 570 571 namespace PR19681 { 572 struct TypoA {}; 573 struct TypoB { 574 void test(); 575 private: 576 template<typename T> void private_memfn(T); // expected-note{{declared here}} 577 }; 578 void TypoB::test() { 579 // FIXME: should suggest 'PR19681::TypoB::private_memfn' instead of '::PR19681::TypoB::private_memfn' 580 (void)static_cast<void(TypoB::*)(int)>(&TypoA::private_memfn); // expected-error{{no member named 'private_memfn' in 'PR19681::TypoA'; did you mean '::PR19681::TypoB::private_memfn'?}} 581 } 582 } 583 584 namespace testWantFunctionLikeCasts { 585 long test(bool a) { 586 if (a) 587 return struc(5.7); // expected-error-re {{use of undeclared identifier 'struc'{{$}}}} 588 else 589 return lon(8.0); // expected-error {{use of undeclared identifier 'lon'; did you mean 'long'?}} 590 } 591 } 592 593 namespace testCXXDeclarationSpecifierParsing { 594 namespace test { 595 struct SomeSettings {}; // expected-note {{'test::SomeSettings' declared here}} 596 } 597 class Test {}; 598 int bar() { 599 Test::SomeSettings some_settings; // expected-error {{no type named 'SomeSettings' in 'testCXXDeclarationSpecifierParsing::Test'; did you mean 'test::SomeSettings'?}} 600 } 601 } 602 603 namespace testNonStaticMemberHandling { 604 struct Foo { 605 bool usesMetadata; // expected-note {{'usesMetadata' declared here}} 606 }; 607 int test(Foo f) { 608 if (UsesMetadata) // expected-error-re {{use of undeclared identifier 'UsesMetadata'{{$}}}} 609 return 5; 610 if (f.UsesMetadata) // expected-error {{no member named 'UsesMetadata' in 'testNonStaticMemberHandling::Foo'; did you mean 'usesMetadata'?}} 611 return 11; 612 return 0; 613 } 614 }; 615 616 namespace testMemberExprDeclarationNameInfo { 617 // The AST should only have the corrected name with no mention of 'data_'. 618 void f(int); 619 struct S { 620 int data; // expected-note 2{{'data' declared here}} 621 void m_fn1() { 622 data_ // expected-error {{use of undeclared identifier 'data_'}} 623 [] = // expected-error {{expected expression}} 624 f(data_); // expected-error {{use of undeclared identifier 'data_'}} 625 } 626 }; 627 } 628 629 namespace testArraySubscriptIndex { 630 struct S { 631 int data; // expected-note {{'data' declared here}} 632 void m_fn1() { 633 (+)[data_]; // expected-error{{expected expression}} expected-error {{use of undeclared identifier 'data_'; did you mean 'data'}} 634 } 635 }; 636 } 637 638 namespace crash_has_include { 639 int has_include(int); // expected-note {{'has_include' declared here}} 640 // expected-error@+1 {{__has_include must be used within a preprocessing directive}} 641 int foo = __has_include(42); // expected-error {{use of undeclared identifier '__has_include'; did you mean 'has_include'?}} 642 } 643 644 namespace PR24781_using_crash { 645 namespace A { 646 namespace B { 647 class Foofoo {}; // expected-note {{'A::B::Foofoo' declared here}} 648 } 649 } 650 651 namespace C { 652 namespace D { 653 class Bar : public A::B::Foofoo {}; 654 } 655 } 656 657 using C::D::Foofoo; // expected-error {{no member named 'Foofoo' in namespace 'PR24781_using_crash::C::D'; did you mean 'A::B::Foofoo'?}} 658 } 659
