clang/test/SemaCXX/warn-overloaded-virtual.cpp

   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 }