Clang Project

clang_source_code/test/SemaCXX/typo-correction.cpp
1// RUN: %clang_cc1 -fspell-checking-limit 0 -verify -Wno-c++11-extensions %s
2
3namespace PR21817{
4int a(-rsing[2]); // expected-error {{undeclared identifier 'rsing'; did you mean 'using'?}}
5                  // expected-error@-1 {{expected expression}}
6}
7
8struct errc {
9  int v_;
10  operator int() const {return v_;}
11};
12
13class error_condition
14{
15  int _val_;
16public:
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
34inline 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.
43struct BaseType { };
44struct 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.
51int 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.
57class some_name {}; // expected-note {{'some_name' declared here}}
58somename Foo; // expected-error {{unknown type name 'somename'; did you mean 'some_name'?}}
59namespace SomeName {} // expected-note {{namespace 'SomeName' defined here}}
60using 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.
66struct st {
67  struct {
68    int field1;
69  };
70  double FieldA; // expected-note{{'FieldA' declared here}}
71};
72st 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.
77typedef char* another_str; // expected-note{{'another_str' declared here}}
78namespace AnotherStd { // expected-note{{'AnotherStd' declared here}}
79  class string {};
80}
81another_std::string str; // expected-error{{use of undeclared identifier 'another_std'; did you mean 'AnotherStd'?}}
82another_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.
86char* TireNames;
87template<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.
92namespace unknown_type_test {
93  class StreamOut {}; // expected-note 2 {{'StreamOut' declared here}}
94  long stream_count; // expected-note 2 {{'stream_count' declared here}}
95};
96unknown_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.
101namespace cache_invalidation_test {
102using namespace unknown_type_test;
103void bar(long i);
104void before_caching_classname() {
105  bar((stream_out)); // expected-error{{use of undeclared identifier 'stream_out'; did you mean 'stream_count'?}}
106}
107stream_out out; // expected-error{{unknown type name 'stream_out'; did you mean 'StreamOut'?}}
108void 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.
114struct BaseDecl {
115  void add_in(int i);
116};
117struct TestRedecl : public BaseDecl {
118  void add_it(int i); // expected-note{{'add_it' declared here}}
119};
120void 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.
124class SomeNetMessage; // expected-note 2{{'SomeNetMessage'}}
125class Message {};
126void foo(Message&);
127void foo(SomeNetMessage&);
128void 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.
137void revoke(const char*); // expected-note 2{{'revoke' declared here}}
138void 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}
143void 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
150void provoke(const char *x, bool y=false) {} // expected-note 2{{'provoke' declared here}}
151void 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.
160struct R {};
161bool begun(R);
162void 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.
169class Parent {
170 void set_types(int index, int value);
171 void add_types(int value);
172};
173class Child: public Parent {};
174void 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.
179namespace clash {
180class ConstructExpr {}; // expected-note 2{{'clash::ConstructExpr' declared here}}
181}
182class 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
192namespace 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
199namespace 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
206namespace 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
224inf f(doulbe); // expected-error{{'int'}} expected-error{{'double'}}
225
226namespace PR6325 {
227class 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'.
231class bar : boo { }; // expected-error{{unknown class name 'boo'; did you mean 'foo'?}}
232}
233
234namespace 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
246namespace 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
275namespace 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
288namespace 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.
292namespace foobar { struct Thing {}; }
293namespace bazquux { struct Thing {}; }
294void f() { Thing t; } // expected-error{{unknown type name 'Thing'}}
295}
296
297namespace bogus_keyword_suggestion {
298void 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
304namespace PR13387 {
305struct A {
306  void CreateFoo(float, float);
307  void CreateBar(float, float);
308};
309struct B : A {
310  using A::CreateFoo; // expected-note {{'CreateFoo' declared here}}
311  void CreateFoo(int, int);  // expected-note {{'CreateFoo' declared here}}
312};
313void f(B &x) {
314  x.Createfoo(0,0);  // expected-error {{no member named 'Createfoo' in 'PR13387::B'; did you mean 'CreateFoo'?}}
315  x.Createfoo(0.f,0.f);  // expected-error {{no member named 'Createfoo' in 'PR13387::B'; did you mean 'CreateFoo'?}}
316}
317}
318
319namespace using_decl {
320  namespace somewhere { int foobar; }
321  using somewhere::foobar; // expected-note {{declared here}}
322  int k = goobar; // expected-error {{did you mean 'foobar'?}}
323}
324
325struct DataStruct {void foo();};
326struct T {
327 DataStruct data_struct;
328 void f();
329};
330// should be void T::f();
331void f() {
332 data_struct->foo();  // expected-error-re{{use of undeclared identifier 'data_struct'{{$}}}}
333}
334
335namespace PR12287 {
336class zif {
337  void nab(int);
338};
339void nab();  // expected-note{{'::PR12287::nab' declared here}}
340void zif::nab(int) {
341  nab();  // expected-error{{too few arguments to function call, expected 1, have 0; did you mean '::PR12287::nab'?}}
342}
343}
344
345namespace TemplateFunction {
346template <class T>
347void A(T) { }  // expected-note {{'::TemplateFunction::A' declared here}}
348
349template <class T>
350void B(T) { }  // expected-note {{'::TemplateFunction::B' declared here}}
351
352class Foo {
353 public:
354  void A(int, int) {}
355  void B() {}
356};
357
358void test(Foo F, int num) {
359  F.A(num);  // expected-error {{too few arguments to function call, expected 2, have 1; did you mean '::TemplateFunction::A'?}}
360  F.B(num);  // expected-error {{too many arguments to function call, expected 0, have 1; did you mean '::TemplateFunction::B'?}}
361}
362}
363namespace using_suggestion_val_dropped_specifier {
364void FFF() {} // expected-note {{'::using_suggestion_val_dropped_specifier::FFF' declared here}}
365namespace N { }
366using 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'?}}
367}
368
369namespace class_member_typo_corrections {
370class Outer {
371public:
372  class Inner {};  // expected-note {{'Outer::Inner' declared here}}
373  Inner MyMethod(Inner arg);
374};
375
376Inner Outer::MyMethod(Inner arg) {  // expected-error {{unknown type name 'Inner'; did you mean 'Outer::Inner'?}}
377  return Inner();
378}
379
380class Result {
381public:
382  enum ResultType {
383    ENTITY,  // expected-note {{'Result::ENTITY' declared here}}
384    PREDICATE,  // expected-note {{'Result::PREDICATE' declared here}}
385    LITERAL  // expected-note {{'Result::LITERAL' declared here}}
386  };
387
388  ResultType type();
389};
390
391void test() {
392  Result result_cell;
393  switch (result_cell.type()) {
394  case ENTITY:  // expected-error {{use of undeclared identifier 'ENTITY'; did you mean 'Result::ENTITY'?}}
395  case LITERAL:  // expected-error {{use of undeclared identifier 'LITERAL'; did you mean 'Result::LITERAL'?}}
396  case PREDICAT:  // expected-error {{use of undeclared identifier 'PREDICAT'; did you mean 'Result::PREDICATE'?}}
397    break;
398  }
399}
400
401class Figure {
402  enum ResultType {
403    SQUARE,
404    TRIANGLE,
405    CIRCLE
406  };
407
408public:
409  ResultType type();
410};
411
412void testAccess() {
413  Figure obj;
414  switch (obj.type()) {
415  case SQUARE:  // expected-error-re {{use of undeclared identifier 'SQUARE'{{$}}}}
416  case TRIANGLE:  // expected-error-re {{use of undeclared identifier 'TRIANGLE'{{$}}}}
417  case CIRCE:  // expected-error-re {{use of undeclared identifier 'CIRCE'{{$}}}}
418    break;
419  }
420}
421}
422
423long readline(const char *, char *, unsigned long);
424void assign_to_unknown_var() {
425    deadline_ = 1;  // expected-error-re {{use of undeclared identifier 'deadline_'{{$}}}}
426}
427
428namespace no_ns_before_dot {
429namespace re2 {}
430void test() {
431    req.set_check(false);  // expected-error-re {{use of undeclared identifier 'req'{{$}}}}
432}
433}
434
435namespace PR17394 {
436  class A {
437  protected:
438    long zzzzzzzzzz;
439  };
440  class B : private A {};
441  B zzzzzzzzzy<>; // expected-error {{expected ';' after top level declarator}}{}
442}
443
444namespace correct_fields_in_member_funcs {
445struct S {
446  int my_member;  // expected-note {{'my_member' declared here}}
447  void f() { my_menber = 1; }  // expected-error {{use of undeclared identifier 'my_menber'; did you mean 'my_member'?}}
448};
449}
450
451namespace PR17019 {
452  template<class F>
453  struct evil {
454    evil(F de) {  // expected-note {{'de' declared here}}
455      de_;  // expected-error {{use of undeclared identifier 'de_'; did you mean 'de'?}} \
456            // expected-warning {{expression result unused}}
457    }
458    ~evil() {
459      de_->bar()  // expected-error {{use of undeclared identifier 'de_'}}
460    }
461  };
462
463  void meow() {
464    evil<int> Q(0); // expected-note {{in instantiation of member function}}
465  }
466}
467
468namespace fix_class_name_qualifier {
469class MessageHeaders {};
470class MessageUtils {
471 public:
472  static void ParseMessageHeaders(int, int); // expected-note {{'MessageUtils::ParseMessageHeaders' declared here}}
473};
474
475void test() {
476  // No, we didn't mean to call MessageHeaders::MessageHeaders.
477  MessageHeaders::ParseMessageHeaders(5, 4); // expected-error {{no member named 'ParseMessageHeaders' in 'fix_class_name_qualifier::MessageHeaders'; did you mean 'MessageUtils::ParseMessageHeaders'?}}
478}
479}
480
481namespace PR18213 {  // expected-note {{'PR18213' declared here}}
482struct WrapperInfo {
483  int i;
484};
485
486template <typename T> struct Wrappable {
487  static WrapperInfo kWrapperInfo;
488};
489
490// Note the space before "::PR18213" is intended and needed, as it highlights
491// the actual typo, which is the leading "::".
492// TODO: Suggest removing the "::" from "::PR18213" (the right correction)
493// instead of incorrectly suggesting dropping "PR18213::WrapperInfo::".
494template <>
495PR18213::WrapperInfo ::PR18213::Wrappable<int>::kWrapperInfo = { 0 };  // expected-error {{no member named 'PR18213' in 'PR18213::WrapperInfo'; did you mean simply 'PR18213'?}} \
496                                                                       // expected-error {{C++ requires a type specifier for all declarations}}
497}
498
499namespace PR18651 {
500struct {
501  int x;
502} a, b;
503
504int y = x;  // expected-error-re {{use of undeclared identifier 'x'{{$}}}}
505}
506
507namespace PR18685 {
508template <class C, int I, int J>
509class SetVector {
510 public:
511  SetVector() {}
512};
513
514template <class C, int I>
515class SmallSetVector : public SetVector<C, I, 8> {};
516
517class foo {};
518SmallSetVector<foo*, 2> fooSet;
519}
520
521PR18685::BitVector Map;  // expected-error-re {{no type named 'BitVector' in namespace 'PR18685'{{$}}}}
522
523namespace shadowed_template {
524template <typename T> class Fizbin {};  // expected-note {{'::shadowed_template::Fizbin' declared here}}
525class Baz {
526   int Fizbin();
527   Fizbin<int> qux;  // expected-error {{no template named 'Fizbin'; did you mean '::shadowed_template::Fizbin'?}}
528};
529}
530
531namespace no_correct_template_id_to_non_template {
532  struct Frobnatz {}; // expected-note {{declared here}}
533  Frobnats fn; // expected-error {{unknown type name 'Frobnats'; did you mean 'Frobnatz'?}}
534  Frobnats<int> fni; // expected-error-re {{no template named 'Frobnats'{{$}}}}
535}
536
537namespace PR18852 {
538void func() {
539  struct foo {
540    void bar() {}
541  };
542  bar();  // expected-error-re {{use of undeclared identifier 'bar'{{$}}}}
543}
544
545class Thread {
546 public:
547  void Start();
548  static void Stop();  // expected-note {{'Thread::Stop' declared here}}
549};
550
551class Manager {
552 public:
553  void Start(int);  // expected-note {{'Start' declared here}}
554  void Stop(int);  // expected-note {{'Stop' declared here}}
555};
556
557void test(Manager *m) {
558  // Don't suggest Thread::Start as a correction just because it has the same
559  // (unqualified) name and accepts the right number of args; this is a method
560  // call on an object in an unrelated class.
561  m->Start();  // expected-error-re {{too few arguments to function call, expected 1, have 0{{$}}}}
562  m->Stop();  // expected-error-re {{too few arguments to function call, expected 1, have 0{{$}}}}
563  Stop();  // expected-error {{use of undeclared identifier 'Stop'; did you mean 'Thread::Stop'?}}
564}
565
566}
567
568namespace std {
569class bernoulli_distribution {
570 public:
571  double p() const;
572};
573}
574void test() {
575  // Make sure that typo correction doesn't suggest changing 'p' to
576  // 'std::bernoulli_distribution::p' as that is most likely wrong.
577  if (p)  // expected-error-re {{use of undeclared identifier 'p'{{$}}}}
578    return;
579}
580
581namespace PR19681 {
582  struct TypoA {};
583  struct TypoB {
584    void test();
585  private:
586    template<typename T> void private_memfn(T);  // expected-note{{declared here}}
587  };
588  void TypoB::test() {
589    // FIXME: should suggest 'PR19681::TypoB::private_memfn' instead of '::PR19681::TypoB::private_memfn'
590    (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'?}}
591  }
592}
593
594namespace testWantFunctionLikeCasts {
595  long test(bool a) {
596    if (a)
597      return struc(5.7);  // expected-error-re {{use of undeclared identifier 'struc'{{$}}}}
598    else
599      return lon(8.0);  // expected-error {{use of undeclared identifier 'lon'; did you mean 'long'?}}
600  }
601}
602
603namespace testCXXDeclarationSpecifierParsing {
604namespace test {
605  struct SomeSettings {};  // expected-note {{'test::SomeSettings' declared here}}
606}
607class Test {};
608int bar() {
609  Test::SomeSettings some_settings; // expected-error {{no type named 'SomeSettings' in 'testCXXDeclarationSpecifierParsing::Test'; did you mean 'test::SomeSettings'?}}
610}
611}
612
613namespace testNonStaticMemberHandling {
614struct Foo {
615  bool usesMetadata;  // expected-note {{'usesMetadata' declared here}}
616};
617int test(Foo f) {
618  if (UsesMetadata)  // expected-error-re {{use of undeclared identifier 'UsesMetadata'{{$}}}}
619    return 5;
620  if (f.UsesMetadata)  // expected-error {{no member named 'UsesMetadata' in 'testNonStaticMemberHandling::Foo'; did you mean 'usesMetadata'?}}
621    return 11;
622  return 0;
623}
624};
625
626namespace testMemberExprDeclarationNameInfo {
627  // The AST should only have the corrected name with no mention of 'data_'.
628  void f(int);
629  struct S {
630    int data;  // expected-note 2{{'data' declared here}}
631    void m_fn1() {
632      data_  // expected-error {{use of undeclared identifier 'data_'}}
633          [] =  // expected-error {{expected expression}}
634          f(data_);  // expected-error {{use of undeclared identifier 'data_'}}
635    }
636  };
637}
638
639namespace testArraySubscriptIndex {
640  struct S {
641    int data;  // expected-note {{'data' declared here}}
642    void m_fn1() {
643      (+)[data_];  // expected-error{{expected expression}} expected-error {{use of undeclared identifier 'data_'; did you mean 'data'}}
644    }
645  };
646}
647
648namespace crash_has_include {
649int has_include(int); // expected-note {{'has_include' declared here}}
650// expected-error@+1 {{'__has_include' must be used within a preprocessing directive}}
651int foo = __has_include(42); // expected-error {{use of undeclared identifier '__has_include'; did you mean 'has_include'?}}
652}
653
654namespace PR24781_using_crash {
655namespace A {
656namespace B {
657class Foofoo {};  // expected-note {{'A::B::Foofoo' declared here}}
658}
659}
660
661namespace C {
662namespace D {
663class Bar : public A::B::Foofoo {};
664}
665}
666
667using C::D::Foofoo;  // expected-error {{no member named 'Foofoo' in namespace 'PR24781_using_crash::C::D'; did you mean 'A::B::Foofoo'?}}
668}
669
670int d = ? L : d; // expected-error {{expected expression}} expected-error {{undeclared identifier}}
671
672struct B0 {
673  int : 0 |         // expected-error {{invalid operands to binary expression}}
674      (struct B0)e; // expected-error {{use of undeclared identifier}}
675};
676
677namespace {
678struct a0is0 {};
679struct b0is0 {};
680int g() {
681  0 [                 // expected-error {{subscripted value is not an array}}
682      sizeof(c0is0)]; // expected-error {{use of undeclared identifier}}
683};
684}
685
686namespace avoidRedundantRedefinitionErrors {
687class Class {
688  void function(int pid); // expected-note {{'function' declared here}}
689};
690
691void Class::function2(int pid) { // expected-error {{out-of-line definition of 'function2' does not match any declaration in 'avoidRedundantRedefinitionErrors::Class'; did you mean 'function'?}}
692}
693
694// Expected no redefinition error here.
695void Class::function(int pid) { // expected-note {{previous definition is here}}
696}
697
698void Class::function(int pid) { // expected-error {{redefinition of 'function'}}
699}
700
701namespace ns {
702void create_test(); // expected-note {{'create_test' declared here}}
703}
704
705void ns::create_test2() { // expected-error {{out-of-line definition of 'create_test2' does not match any declaration in namespace 'avoidRedundantRedefinitionErrors::ns'; did you mean 'create_test'?}}
706}
707
708// Expected no redefinition error here.
709void ns::create_test() {
710}
711}
712
CodeThinker, Enjoy your reading code