1// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions %s
2//
3// WARNING: Do not add more typo correction test cases to this file lest you run
4// afoul the hard-coded limit (escape hatch) of 20 different typos whose
5// correction was attempted by Sema::CorrectTypo
6
7struct errc {
8  int v_;
9  operator int() const {return v_;}
10};
11
12class error_condition
13{
14  int _val_;
15public:
16  error_condition() : _val_(0) {}
17
18  error_condition(int _val)
19    : _val_(_val) {}
20
21  template <class E>
22  error_condition(E _e) {
23    // make_error_condition must not be typo corrected to error_condition
24    // even though the first declaration of make_error_condition has not
25    // yet been encountered. This was a bug in the first version of the type
26    // name typo correction patch that wasn't noticed until building LLVM with
27    // Clang failed.
28    *this = make_error_condition(_e);
29  }
30
31};
32
33inline error_condition make_error_condition(errc _e) {
34  return error_condition(static_cast<int>(_e));
35}
36
37
38// Prior to the introduction of a callback object to further filter possible
39// typo corrections, this example would not trigger a suggestion as "base_type"
40// is a closer match to "basetype" than is "BaseType" but "base_type" does not
41// refer to a base class or non-static data member.
42struct BaseType { };
43struct Derived : public BaseType { // expected-note {{base class 'BaseType' specified here}}
44  static int base_type; // expected-note {{'base_type' declared here}}
45  Derived() : basetype() {} // expected-error{{initializer 'basetype' does not name a non-static data member or base class; did you mean the base class 'BaseType'?}}
46};
47
48// Test the improvement from passing a callback object to CorrectTypo in
49// the helper function LookupMemberExprInRecord.
50int get_type(struct Derived *st) {
51  return st->Base_Type; // expected-error{{no member named 'Base_Type' in 'Derived'; did you mean 'base_type'?}}
52}
53
54// In this example, somename should not be corrected to the cached correction
55// "some_name" since "some_name" is a class and a namespace name is needed.
56class some_name {}; // expected-note {{'some_name' declared here}}
57somename Foo; // expected-error {{unknown type name 'somename'; did you mean 'some_name'?}}
58namespace SomeName {} // expected-note {{namespace 'SomeName' defined here}}
59using namespace somename; // expected-error {{no namespace named 'somename'; did you mean 'SomeName'?}}
60
61
62// Without the callback object, CorrectTypo would choose "field1" as the
63// correction for "fielda" as it is closer than "FieldA", but that correction
64// would be later discarded by the caller and no suggestion would be given.
65struct st {
66  struct {
67    int field1;
68  };
69  double FieldA; // expected-note{{'FieldA' declared here}}
70};
71st var = { .fielda = 0.0 }; // expected-error{{field designator 'fielda' does not refer to any field in type 'st'; did you mean 'FieldA'?}}
72
73// Test the improvement from passing a callback object to CorrectTypo in
74// Sema::BuildCXXNestedNameSpecifier. And also for the improvement by doing
75// so in Sema::getTypeName.
76typedef char* another_str; // expected-note{{'another_str' declared here}}
77namespace AnotherStd { // expected-note{{'AnotherStd' declared here}}
78  class string {};
79}
80another_std::string str; // expected-error{{use of undeclared identifier 'another_std'; did you mean 'AnotherStd'?}}
81another_str *cstr = new AnotherStr; // expected-error{{unknown type name 'AnotherStr'; did you mean 'another_str'?}}
82
83// Test the improvement from passing a callback object to CorrectTypo in
84// Sema::ActOnSizeofParameterPackExpr.
85char* TireNames;
86template<typename ...TypeNames> struct count { // expected-note{{parameter pack 'TypeNames' declared here}}
87  static const unsigned value = sizeof...(TyreNames); // expected-error{{'TyreNames' does not refer to the name of a parameter pack; did you mean 'TypeNames'?}}
88};
89
90// Test the typo-correction callback in Sema::DiagnoseUnknownTypeName.
91namespace unknown_type_test {
92  class StreamOut {}; // expected-note 2 {{'StreamOut' declared here}}
93  long stream_count; // expected-note 2 {{'stream_count' declared here}}
94};
95unknown_type_test::stream_out out; // expected-error{{no type named 'stream_out' in namespace 'unknown_type_test'; did you mean 'StreamOut'?}}
96
97// Demonstrate a case where using only the cached value returns the wrong thing
98// when the cached value was the result of a previous callback object that only
99// accepts a subset of the current callback object.
100namespace {
101using namespace unknown_type_test;
102void bar(long i);
103void before_caching_classname() {
104  bar((stream_out)); // expected-error{{use of undeclared identifier 'stream_out'; did you mean 'stream_count'?}}
105}
106stream_out out; // expected-error{{unknown type name 'stream_out'; did you mean 'StreamOut'?}}
107void after_caching_classname() {
108  bar((stream_out)); // expected-error{{use of undeclared identifier 'stream_out'; did you mean 'stream_count'?}}
109}
110}
111
112// Test the typo-correction callback in Sema::DiagnoseInvalidRedeclaration.
113struct BaseDecl {
114  void add_in(int i);
115};
116struct TestRedecl : public BaseDecl {
117  void add_it(int i); // expected-note{{'add_it' declared here}}
118};
119void 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'?}}
120
121// Test the improved typo correction for the Parser::ParseCastExpr =>
122// Sema::ActOnIdExpression => Sema::DiagnoseEmptyLookup call path.
123class SomeNetMessage; // expected-note 2{{'SomeNetMessage'}}
124class Message {};
125void foo(Message&);
126void foo(SomeNetMessage&);
127void doit(void *data) {
128  Message somenetmsg; // expected-note{{'somenetmsg' declared here}}
129  foo(somenetmessage); // expected-error{{use of undeclared identifier 'somenetmessage'; did you mean 'somenetmsg'?}}
130  foo((somenetmessage)data); // expected-error{{unknown type name 'somenetmessage'; did you mean 'SomeNetMessage'?}} expected-error{{incomplete type}}
131}
132
133// Test the typo-correction callback in BuildRecoveryCallExpr.
134// Solves the main issue in PR 9320 of suggesting corrections that take the
135// wrong number of arguments.
136void revoke(const char*); // expected-note 2{{'revoke' declared here}}
137void Test() {
138  Invoke(); // expected-error{{use of undeclared identifier 'Invoke'}}
139  Invoke("foo"); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'revoke'?}}
140  Invoke("foo", "bar"); // expected-error{{use of undeclared identifier 'Invoke'}}
141}
142void Test2(void (*invoke)(const char *, int)) { // expected-note{{'invoke' declared here}}
143  Invoke(); // expected-error{{use of undeclared identifier 'Invoke'}}
144  Invoke("foo"); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'revoke'?}}
145  Invoke("foo", 7); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'invoke'?}}
146  Invoke("foo", 7, 22); // expected-error{{use of undeclared identifier 'Invoke'}}
147}
148
149void provoke(const char *x, bool y=false) {} // expected-note 2{{'provoke' declared here}}
150void Test3() {
151  Provoke(); // expected-error{{use of undeclared identifier 'Provoke'}}
152  Provoke("foo"); // expected-error{{use of undeclared identifier 'Provoke'; did you mean 'provoke'?}}
153  Provoke("foo", true); // expected-error{{use of undeclared identifier 'Provoke'; did you mean 'provoke'?}}
154  Provoke("foo", 7, 22); // expected-error{{use of undeclared identifier 'Provoke'}}
155}
156
157// PR 11737 - Don't try to typo-correct the implicit 'begin' and 'end' in a
158// C++11 for-range statement.
159struct R {};
160bool begun(R);
161void RangeTest() {
162  for (auto b : R()) {} // expected-error {{invalid range expression of type 'R'}}
163}
164
165// PR 12019 - Avoid infinite mutual recursion in DiagnoseInvalidRedeclaration
166// by not trying to typo-correct a method redeclaration to declarations not
167// in the current record.
168class Parent {
169 void set_types(int index, int value);
170 void add_types(int value);
171};
172class Child: public Parent {};
173void Child::add_types(int value) {} // expected-error{{out-of-line definition of 'add_types' does not match any declaration in 'Child'}}
174
175// Fix the callback based filtering of typo corrections within
176// Sema::ActOnIdExpression by Parser::ParseCastExpression to allow type names as
177// potential corrections for template arguments.
178namespace clash {
179class ConstructExpr {}; // expected-note 2{{'clash::ConstructExpr' declared here}}
180}
181class ClashTool {
182  bool HaveConstructExpr();
183  template <class T> T* getExprAs();
184
185  void test() {
186    ConstructExpr *expr = // expected-error{{unknown type name 'ConstructExpr'; did you mean 'clash::ConstructExpr'?}}
187        getExprAs<ConstructExpr>(); // expected-error{{unknown type name 'ConstructExpr'; did you mean 'clash::ConstructExpr'?}}
188  }
189};
190
191namespace test1 {
192  struct S {
193    struct Foobar *f;  // expected-note{{'Foobar' declared here}}
194  };
195  test1::FooBar *b;  // expected-error{{no type named 'FooBar' in namespace 'test1'; did you mean 'Foobar'?}}
196}
197
198namespace ImplicitInt {
199  void f(int, unsinged); // expected-error{{did you mean 'unsigned'}}
200  struct S {
201    unsinged : 4; // expected-error{{did you mean 'unsigned'}}
202  };
203}
204
205namespace PR13051 {
206  template<typename T> struct S {
207    template<typename U> void f();
208    operator bool() const;
209  };
210
211  void foo(); // expected-note{{'foo' declared here}}
212  void g(void(*)());
213  void g(bool(S<int>::*)() const);
214
215  void test() {
216    g(&S<int>::tempalte f<int>); // expected-error{{did you mean 'template'?}}
217    g(&S<int>::opeartor bool); // expected-error{{did you mean 'operator'?}}
218    g(&S<int>::foo); // expected-error{{no member named 'foo' in 'PR13051::S<int>'; did you mean simply 'foo'?}}
219  }
220}
221
222inf f(doulbe); // expected-error{{'int'}} expected-error{{'double'}}
223
224namespace PR6325 {
225class foo { }; // expected-note{{'foo' declared here}}
226// Note that for this example (pulled from the PR), if keywords are not excluded
227// as correction candidates then no suggestion would be given; correcting
228// 'boo' to 'bool' is the same edit distance as correcting 'boo' to 'foo'.
229class bar : boo { }; // expected-error{{unknown class name 'boo'; did you mean 'foo'?}}
230}
231
232namespace outer {
233  void somefunc();  // expected-note{{'::outer::somefunc' declared here}}
234  void somefunc(int, int);  // expected-note{{'::outer::somefunc' declared here}}
235
236  namespace inner {
237    void somefunc(int) {
238      someFunc();  // expected-error{{use of undeclared identifier 'someFunc'; did you mean '::outer::somefunc'?}}
239      someFunc(1, 2);  // expected-error{{use of undeclared identifier 'someFunc'; did you mean '::outer::somefunc'?}}
240    }
241  }
242}
243
244namespace b6956809_test1 {
245  struct A {};
246  struct B {};
247
248  struct S1 {
249    void method(A*);  // no note here
250    void method(B*);
251  };
252
253  void test1() {
254    B b;
255    S1 s;
256    s.methodd(&b);  // expected-error{{no member named 'methodd' in 'b6956809_test1::S1'; did you mean 'method'}}
257  }
258
259  struct S2 {
260    S2();
261    void method(A*) const;  // expected-note{{candidate function not viable}}
262   private:
263    void method(B*);  // expected-note{{candidate function not viable}}
264  };
265
266  void test2() {
267    B b;
268    const S2 s;
269    s.methodd(&b);  // expected-error{{no member named 'methodd' in 'b6956809_test1::S2'; did you mean 'method'}}  expected-error{{no matching member function for call to 'method'}}
270  }
271}
272
273namespace b6956809_test2 {
274  template<typename T> struct Err { typename T::error n; };  // expected-error{{type 'void *' cannot be used prior to '::' because it has no members}}
275  struct S {
276    template<typename T> typename Err<T>::type method(T);  // expected-note{{in instantiation of template class 'b6956809_test2::Err<void *>' requested here}}
277    template<typename T> int method(T *);
278  };
279
280  void test() {
281    S s;
282    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 *]}}
283  }
284}
285
286// This test should have one correction, followed by an error without a
287// suggestion due to exceeding the maximum number of typos for which correction
288// is attempted.
289namespace CorrectTypo_has_reached_its_limit {
290int flibberdy();  // expected-note{{'flibberdy' declared here}}
291int no_correction() {
292  return hibberdy() +  // expected-error{{use of undeclared identifier 'hibberdy'; did you mean 'flibberdy'?}}
293         gibberdy();  // expected-error-re{{use of undeclared identifier 'gibberdy'{{$}}}}
294};
295}
296