Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -Woverloaded-virtual -verify %s
      2 
      3 struct B1 {
      4   virtual void foo(int); // expected-note {{declared here}}
      5   virtual void foo(); // expected-note {{declared here}}
      6 };
      7 
      8 struct S1 : public B1 {
      9   void foo(float); // expected-warning {{hides overloaded virtual functions}}
     10 };
     11 
     12 struct S2 : public B1 {
     13   void foo(); // expected-note {{declared here}}
     14 };
     15 
     16 struct B2 {
     17   virtual void foo(void*); // expected-note {{declared here}}
     18 };
     19 
     20 struct MS1 : public S2, public B2 {
     21    virtual void foo(int); // expected-warning {{hides overloaded virtual functions}}
     22 };
     23 
     24 struct B3 {
     25   virtual void foo(int);
     26   virtual void foo();
     27 };
     28 
     29 struct S3 : public B3 {
     30   using B3::foo;
     31   void foo(float);
     32 };
     33 
     34 struct B4 {
     35   virtual void foo();
     36 };
     37 
     38 struct S4 : public B4 {
     39   void foo(float);
     40   void foo();
     41 };
     42 
     43 namespace PR9182 {
     44 struct Base {
     45   virtual void foo(int);
     46 };
     47 
     48 void Base::foo(int) { }
     49 
     50 struct Derived : public Base {
     51   virtual void foo(int);
     52   void foo(int, int);
     53 };
     54 }
     55 
     56 namespace PR9396 {
     57 class A {
     58 public:
     59   virtual void f(int) {}
     60 };
     61 
     62 class B : public A {
     63 public:
     64   static void f() {}
     65 };
     66 }
     67 
     68 namespace ThreeLayer {
     69 struct A {
     70   virtual void f();
     71 };
     72 
     73 struct B: A {
     74   void f();
     75   void f(int);
     76 };
     77 
     78 struct C: B {
     79   void f(int);
     80   using A::f;
     81 };
     82 }
     83 
     84 namespace UnbalancedVirtual {
     85 struct Base {
     86   virtual void func();
     87 };
     88 
     89 struct Derived1: virtual Base {
     90   virtual void func();
     91 };
     92 
     93 struct Derived2: virtual Base {
     94 };
     95 
     96 struct MostDerived: Derived1, Derived2 {
     97   void func(int);
     98   void func();
     99 };
    100 }
    101 
    102 namespace UnbalancedVirtual2 {
    103 struct Base {
    104   virtual void func();
    105 };
    106 
    107 struct Derived1: virtual Base {
    108   virtual void func();
    109 };
    110 
    111 struct Derived2: virtual Base {
    112 };
    113 
    114 struct Derived3: Derived1 {
    115   virtual void func();
    116 };
    117 
    118 struct MostDerived: Derived3, Derived2 {
    119   void func(int);
    120   void func();
    121 };
    122 }
    123 
    124 namespace {
    125   class A {
    126     virtual int foo(bool) const;
    127     // expected-note@-1{{type mismatch at 1st parameter ('bool' vs 'int')}}
    128     virtual int foo(int, int) const;
    129     // expected-note@-1{{different number of parameters (2 vs 1)}}
    130     virtual int foo(int*) const;
    131     // expected-note@-1{{type mismatch at 1st parameter ('int *' vs 'int')}}
    132     virtual int foo(int) volatile;
    133     // expected-note@-1{{different qualifiers (volatile vs const)}}
    134   };
    135 
    136   class B : public A {
    137     virtual int foo(int) const;
    138     // expected-warning@-1{{hides overloaded virtual functions}}
    139   };
    140 }
    141 
    142 namespace {
    143 struct base {
    144   void f(char) {}
    145 };
    146 
    147 struct derived : base {
    148   void f(int) {}
    149 };
    150 
    151 void foo(derived &d) {
    152   d.f('1'); // FIXME: this should warn about calling (anonymous namespace)::derived::f(int)
    153             // instead of (anonymous namespace)::base::f(char).
    154             // Note: this should be under a new diagnostic flag and eventually moved to a
    155             // new test case since it's not strictly related to virtual functions.
    156   d.f(12);  // This should not warn.
    157 }
    158 }
    159