1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 int foo(int);
3 
4 namespace N {
5   void f1() {
6     void foo(int); // okay
7     void bar(int); // expected-note 2{{previous declaration is here}}
8   }
9 
10   void foo(int); // expected-note 3{{previous declaration is here}}
11 
12   void f2() {
13     int foo(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
14     int bar(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
15     int baz(int); // expected-note {{previous declaration is here}}
16 
17     {
18       int foo;
19       int bar;
20       int baz;
21       {
22         float foo(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
23         float bar(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
24         float baz(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
25       }
26     }
27   }
28 
29   void f3() {
30     int foo(float);
31     {
32       float foo(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
33     }
34   }
35 }
36 
37 class A {
38  void typocorrection(); // expected-note {{'typocorrection' declared here}}
39 };
40 
41 void A::Notypocorrection() { // expected-error {{out-of-line definition of 'Notypocorrection' does not match any declaration in 'A'; did you mean 'typocorrection'}}
42 }
43 
44 
45 namespace test0 {
46   void dummy() {
47     void Bar(); // expected-note {{'Bar' declared here}}
48     class A {
49       friend void bar(); // expected-error {{no matching function 'bar' found in local scope; did you mean 'Bar'}}
50     };
51   }
52 }
53 
54 
55 class B {
56  void typocorrection(const int); // expected-note {{'typocorrection' declared here}}
57  void typocorrection(double);
58 };
59 
60 void B::Notypocorrection(int) { // expected-error {{out-of-line definition of 'Notypocorrection' does not match any declaration in 'B'; did you mean 'typocorrection'}}
61 }
62 
63 struct X { int f(); };
64 struct Y : public X {};
65 int Y::f() { return 3; } // expected-error {{out-of-line definition of 'f' does not match any declaration in 'Y'}}
66 
67 namespace test1 {
68 struct Foo {
69   class Inner { };
70 };
71 }
72 
73 class Bar {
74   void f(test1::Foo::Inner foo) const; // expected-note {{member declaration does not match because it is const qualified}}
75 };
76 
77 using test1::Foo;
78 
79 void Bar::f(Foo::Inner foo) { // expected-error {{out-of-line definition of 'f' does not match any declaration in 'Bar'}}
80   (void)foo;
81 }
82 
83 class Crash {
84  public:
85   void GetCart(int count) const;
86 };
87 // This out-of-line definition was fine...
88 void Crash::cart(int count) const {} // expected-error {{out-of-line definition of 'cart' does not match any declaration in 'Crash'}}
89 // ...while this one crashed clang
90 void Crash::chart(int count) const {} // expected-error {{out-of-line definition of 'chart' does not match any declaration in 'Crash'}}
91 
92 class TestConst {
93  public:
94   int getit() const; // expected-note {{member declaration does not match because it is const qualified}}
95   void setit(int); // expected-note {{member declaration does not match because it is not const qualified}}
96 };
97 
98 int TestConst::getit() { // expected-error {{out-of-line definition of 'getit' does not match any declaration in 'TestConst'}}
99   return 1;
100 }
101 
102 void TestConst::setit(int) const { // expected-error {{out-of-line definition of 'setit' does not match any declaration in 'TestConst'}}
103 }
104 
105 struct J { int typo() const; };
106 int J::typo_() { return 3; } // expected-error {{out-of-line definition of 'typo_' does not match any declaration in 'J'}}
107 
108 // Ensure we correct the redecl of Foo::isGood to Bar::Foo::isGood and not
109 // Foo::IsGood even though Foo::IsGood is technically a closer match since it
110 // already has a body. Also make sure Foo::beEvil is corrected to Foo::BeEvil
111 // since it is a closer match than Bar::Foo::beEvil and neither have a body.
112 namespace redecl_typo {
113 namespace Foo {
114   bool IsGood() { return false; }
115   void BeEvil(); // expected-note {{'BeEvil' declared here}}
116 }
117 namespace Bar {
118   namespace Foo {
119     bool isGood(); // expected-note {{'Bar::Foo::isGood' declared here}}
120     void beEvil();
121   }
122 }
123 bool Foo::isGood() { // expected-error {{out-of-line definition of 'isGood' does not match any declaration in namespace 'redecl_typo::Foo'; did you mean 'Bar::Foo::isGood'?}}
124   return true;
125 }
126 void Foo::beEvil() {} // expected-error {{out-of-line definition of 'beEvil' does not match any declaration in namespace 'redecl_typo::Foo'; did you mean 'BeEvil'?}}
127 }
128