1 // RUN: %clang_cc1 -fspell-checking-limit 0 -verify -Wno-c++11-extensions %s
4 int a(-rsing[2]); // expected-error {{undeclared identifier 'rsing'; did you mean 'using'?}}
5 // expected-error@-1 {{expected expression}}
10 operator int() const {return v_;}
17 error_condition() : _val_(0) {}
19 error_condition(int _val)
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
29 *this = make_error_condition(_e);
34 inline error_condition make_error_condition(errc _e) {
35 return error_condition(static_cast<int>(_e));
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.
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'?}}
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'?}}
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'?}}
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.
70 double FieldA; // expected-note{{'FieldA' declared here}}
72 st var = { .fielda = 0.0 }; // expected-error{{field designator 'fielda' does not refer to any field in type 'st'; did you mean 'FieldA'?}}
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}}
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'?}}
84 // Test the improvement from passing a callback object to CorrectTypo in
85 // Sema::ActOnSizeofParameterPackExpr.
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'?}}
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}}
96 unknown_type_test::stream_out out; // expected-error{{no type named 'stream_out' in namespace 'unknown_type_test'; did you mean 'StreamOut'?}}
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;
104 void before_caching_classname() {
105 bar((stream_out)); // expected-error{{use of undeclared identifier 'stream_out'; did you mean 'stream_count'?}}
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'?}}
113 // Test the typo-correction callback in Sema::DiagnoseInvalidRedeclaration.
117 struct TestRedecl : public BaseDecl {
118 void add_it(int i); // expected-note{{'add_it' declared here}}
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'?}}
122 // Test the improved typo correction for the Parser::ParseCastExpr =>
123 // Sema::ActOnIdExpression => Sema::DiagnoseEmptyLookup call path.
124 class SomeNetMessage; // expected-note 2{{'SomeNetMessage'}}
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}}
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}}
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'}}
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'}}
150 void provoke(const char *x, bool y=false) {} // expected-note 2{{'provoke' declared here}}
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'}}
158 // PR 11737 - Don't try to typo-correct the implicit 'begin' and 'end' in a
159 // C++11 for-range statement.
163 for (auto b : R()) {} // expected-error {{invalid range expression of type 'R'}}
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.
170 void set_types(int index, int value);
171 void add_types(int value);
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'}}
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.
180 class ConstructExpr {}; // expected-note 2{{'clash::ConstructExpr' declared here}}
183 bool HaveConstructExpr();
184 template <class T> T* getExprAs();
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'?}}
194 struct Foobar *f; // expected-note{{'Foobar' declared here}}
196 test1::FooBar *b; // expected-error{{no type named 'FooBar' in namespace 'test1'; did you mean 'Foobar'?}}
199 namespace ImplicitInt {
200 void f(int, unsinged); // expected-error{{did you mean 'unsigned'}}
202 unsinged : 4; // expected-error{{did you mean 'unsigned'}}
207 template<typename T> struct S {
208 template<typename U> void f();
209 operator bool() const;
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}}
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'?}}
224 inf f(doulbe); // expected-error{{'int'}} expected-error{{'double'}}
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'?}}
235 void somefunc(); // expected-note{{'::outer::somefunc' declared here}}
236 void somefunc(int, int); // expected-note{{'::outer::somefunc' declared here}}
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'?}}
246 namespace b6956809_test1 {
251 void method(A*); // no note here
252 void method(B*); // expected-note{{'method' declared here}}
258 s.methodd(&b); // expected-error{{no member named 'methodd' in 'b6956809_test1::S1'; did you mean 'method'}}
263 void method(A*) const;
271 s.methodd(&b); // expected-error-re{{no member named 'methodd' in 'b6956809_test1::S2'{{$}}}}
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}}
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}}
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 *]}}
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'}}
297 namespace bogus_keyword_suggestion {
299 status = "OK"; // expected-error-re {{use of undeclared identifier 'status'{{$}}}}
300 return status; // expected-error-re {{use of undeclared identifier 'status'{{$}}}}
306 void CreateFoo(float, float);
307 void CreateBar(float, float);
311 void CreateFoo(int, int); // expected-note {{'CreateFoo' declared here}}
314 x.Createfoo(0,0); // expected-error {{no member named 'Createfoo' in 'PR13387::B'; did you mean 'CreateFoo'?}}
318 struct DataStruct {void foo();};
320 DataStruct data_struct;
323 // should be void T::f();
325 data_struct->foo(); // expected-error-re{{use of undeclared identifier 'data_struct'{{$}}}}
332 void nab(); // expected-note{{'::PR12287::nab' declared here}}
334 nab(); // expected-error{{too few arguments to function call, expected 1, have 0; did you mean '::PR12287::nab'?}}
338 namespace TemplateFunction {
340 void A(T) { } // expected-note {{'::TemplateFunction::A' declared here}}
343 void B(T) { } // expected-note {{'::TemplateFunction::B' declared here}}
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'?}}
356 namespace using_suggestion_val_dropped_specifier {
357 void FFF() {} // expected-note {{'::using_suggestion_val_dropped_specifier::FFF' declared here}}
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'?}}
362 namespace class_member_typo_corrections {
365 class Inner {}; // expected-note {{'Outer::Inner' declared here}}
366 Inner MyMethod(Inner arg);
369 Inner Outer::MyMethod(Inner arg) { // expected-error {{unknown type name 'Inner'; did you mean 'Outer::Inner'?}}
376 ENTITY, // expected-note {{'Result::ENTITY' declared here}}
377 PREDICATE, // expected-note {{'Result::PREDICATE' declared here}}
378 LITERAL // expected-note {{'Result::LITERAL' declared here}}
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'?}}
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'{{$}}}}
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_'{{$}}}}
421 namespace no_ns_before_dot {
424 req.set_check(false); // expected-error-re {{use of undeclared identifier 'req'{{$}}}}
433 class B : private A {};
434 B zzzzzzzzzy<>; // expected-error {{expected ';' after top level declarator}}{}
437 namespace correct_fields_in_member_funcs {
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'?}}
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}}
452 de_->bar() // expected-error {{use of undeclared identifier 'de_'}}
457 evil<int> Q(0); // expected-note {{in instantiation of member function}}
461 namespace fix_class_name_qualifier {
462 class MessageHeaders {};
465 static void ParseMessageHeaders(int, int); // expected-note {{'MessageUtils::ParseMessageHeaders' declared here}}
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'?}}
474 namespace PR18213 { // expected-note {{'PR18213' declared here}}
479 template <typename T> struct Wrappable {
480 static WrapperInfo kWrapperInfo;
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::".
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}}
497 int y = x; // expected-error-re {{use of undeclared identifier 'x'{{$}}}}
501 template <class C, int I, int J>
507 template <class C, int I>
508 class SmallSetVector : public SetVector<C, I, 8> {};
511 SmallSetVector<foo*, 2> fooSet;
514 PR18685::BitVector Map; // expected-error-re {{no type named 'BitVector' in namespace 'PR18685'{{$}}}}
516 namespace shadowed_template {
517 template <typename T> class Fizbin {}; // expected-note {{'::shadowed_template::Fizbin' declared here}}
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}}
532 bar(); // expected-error-re {{use of undeclared identifier 'bar'{{$}}}}
538 static void Stop(); // expected-note {{'Thread::Stop' declared here}}
543 void Start(int); // expected-note {{'Start' declared here}}
544 void Stop(int); // expected-note {{'Stop' declared here}}
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'?}}
559 class bernoulli_distribution {
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'{{$}}}}
576 template<typename T> void private_memfn(T); // expected-note{{declared here}}
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'?}}
584 namespace testWantFunctionLikeCasts {
587 return struc(5.7); // expected-error-re {{use of undeclared identifier 'struc'{{$}}}}
589 return lon(8.0); // expected-error {{use of undeclared identifier 'lon'; did you mean 'long'?}}
593 namespace testCXXDeclarationSpecifierParsing {
595 struct SomeSettings {}; // expected-note {{'test::SomeSettings' declared here}}
599 Test::SomeSettings some_settings; // expected-error {{no type named 'SomeSettings' in 'testCXXDeclarationSpecifierParsing::Test'; did you mean 'test::SomeSettings'?}}
603 namespace testNonStaticMemberHandling {
605 bool usesMetadata; // expected-note {{'usesMetadata' declared here}}
608 if (UsesMetadata) // expected-error-re {{use of undeclared identifier 'UsesMetadata'{{$}}}}
610 if (f.UsesMetadata) // expected-error {{no member named 'UsesMetadata' in 'testNonStaticMemberHandling::Foo'; did you mean 'usesMetadata'?}}
616 namespace testMemberExprDeclarationNameInfo {
617 // The AST should only have the corrected name with no mention of 'data_'.
620 int data; // expected-note 2{{'data' declared here}}
622 data_ // expected-error {{use of undeclared identifier 'data_'}}
623 [] = // expected-error {{expected expression}}
624 f(data_); // expected-error {{use of undeclared identifier 'data_'}}
629 namespace testArraySubscriptIndex {
631 int data; // expected-note {{'data' declared here}}
633 (+)[data_]; // expected-error{{expected expression}} expected-error {{use of undeclared identifier 'data_'; did you mean 'data'}}
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'?}}