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