Home | History | Annotate | Download | only in SemaCXX 
      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