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